HomeGEMDOSDatum und UhrzeitSpeicherverwaltung

5.11 Prozessfunktionen

Pause        Prozess bis zum Eintreffen eines Signales suspendieren.
Pdomain      Prozess-Umgebung setzen bzw. erfragen.
Pexec        Weiteres Programm laden und ausführen.
Pfork        Kopie des aktuellen Prozesses erzeugen.
Pgetauid     User-ID eines Prozesses zu Beginn ermitteln.
Pgetegid     Effektive Gruppen-ID eines Prozesses ermitteln.
Pgeteuid     Effektive User-ID eines Prozesses ermitteln.
Pgetgid      Gruppen-ID eines Prozesses ermitteln.
Pgetgroups   gets the supplementary group ids for the calling process.
Pgetpgrp     Aktuelle Prozess-Gruppennummer erfragen.
Pgetpid      Aktuelle Prozess-ID erfragen.
Pgetppid     Prozess-ID für Vater-Prozess erfragen.
Pgetpriority gets the current priority value for a process.
Pgetuid      User-ID eines Prozesses ermitteln.
Pkill        Signal zu einem Prozess schicken.
Pmsg         Nachrichten senden und empfangen.
Pnice        Priorität des aktuellen Prozesses verändern.
Prenice      Priorität eines Prozesses verändern.
Prusage      Informationen über Resourcenverbrauch ermitteln.
Psemaphore   Erzeugen, anwenden, zerstören einer Semaphore.
Psetauid     User-ID eines Prozesses zu Beginn setzen.
Psetegid     Effektive Gruppen-ID eines Prozesses setzen.
Pseteuid     Effektive User-ID eines Prozesses setzen.
Psetgid      Gruppen-ID eines Prozesses verändern.
Psetgroups   sets the supplementary group ids for the calling process.
Psetlimit    Limits der Systemresourcen setzen/erfragen.
Psetpgrp     Prozess-Gruppennummer eines Prozesses setzen.
Psetpriority sets the current priority value for a process.
Psetregid    sets the real and/or effective group id for the calling process.
Psetreuid    sets the real and/or effective user id for the calling process.
Psetuid      User-ID eines Prozesses verändern.
Psigaction   Art der Signalbehandlung verändern.
Psigblock    Signalmaske verändern.
Psigintr     Assigns a signal to a particular exception vector.
Psignal      Art der Signalbehandlung verändern.
Psigpause    Signalmaske setzen und Prozess bis zum Eintreffen eines Signals suspendieren.
Psigpending  Kontrollieren von abgeschickten Signalen.
Psigreturn   Verlassen eines Signal-Handlers.
Psigsetmask  Signalmaske ersetzen.
Pterm        Programm beenden und Wert an Aufrufer zurückgeben.
Pterm0       Programm beenden und 0 an Aufrufer zurückgeben.
Ptermres     Programm beenden, aber im Speicher behalten.
Ptrace       Process tracing and debugging.
Pumask       Erstellungsmaske für Dateien/Verzeichnisse setzen.
Pusrval      Spezifische Informationen eines Prozesses setzen/erfragen.
Pvfork       Kopie des aktuellen Prozesses erstellen.
Pwait        Auf Childprozess warten, Exitcode ermitteln.
Pwait3       Exitcode eines Childprozess ermitteln.
Pwaitpid     Exitcode eines oder mehrerer Childs ermitteln.

Querverweis: Speicherverwaltung   Signale   Task-Manager

5.11.1 Pause

Name: »Pause« - Prozess bis zum Eintreffen eines Signals suspendieren.
Gemdosnummer: 289
Deklaration: void Pause ( void );
Beschreibung: Die Funktion suspendiert den aufrufenden Prozeß, bis ein Signal für diesen eintrifft. Wenn für dieses Signal ein Signal-Handler mittels Psignal installiert worden ist, wird der Handler aufgerufen, bevor die Funktion Pause zurückkehrt.

Die Funktion wird nicht zurückkehren, wenn der Signal-Handler einen nicht lokalen Sprung (per longjump) ausführt, oder das Programm beendet wird.
Ergebnis: Die Funktion hat kein direktes Ergebnis.
Verfügbar: Seit der ersten in MultiTOS integrierten MiNT Version 1.04 und MagiC ab Version 4.50.
Gruppe: Prozessfunktionen
Querverweis: Binding   Psigblock   Psignal   Psigpause   Psigsetmask   Signale

5.11.1.1 Bindings für Pause

C: void Pause ( void );
Assembler:
move.w    #289,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #2,sp        ; Stack korrigieren

5.11.2 Pdomain

Name: »Pdomain« - Prozessumgebung setzen bzw. erfragen.
Gemdosnummer: 281
Deklaration: int16_t Pdomain ( int16_t dom );
Beschreibung: Die Funktion dient dem Setzen bzw. Abfragen der Umgebung, in der der Prozeß ausgeführt wird. Diese Umgebung beeinflußt das Verhalten des Prozesses zum Teil drastisch. Es gilt:
dom Bedeutung
   
-1 aktuell gültige Domain erfragen.
 0 TOS-Domain (Default-Wert). In dieser Umgebung verhalten sich alle Systemaufrufe exakt genauso wie unter dem normalen TOS.
 1 MiNT-Domain. In dieser Umgebung wird das Verhalten von Fread und Fwrite durch die von Fcntl eingestellten Parameter beeinflußt, wenn diese auf ein Terminal angewendet werden. Außerdem werden Dateinamen die per Fsfirst bzw. Fsnext geliefert werden, anders behandelt.



Hinweis: MiNT-kompatible Prozesse sollten auch mit Dateien umgehen können, die nicht der Standard DOS-Konvention (8+3 Zeichen) entsprechen.
Ergebnis: Die Funktion liefert die Umgebung des Prozesses zurück, die beim Funktionsaufruf gültig war.
Verfügbar: Seit der ersten in MultiTOS integrierten MiNT Version 1.04 und MagiC ab Version 4.0 (05.11.1995).
Gruppe: Prozessfunktionen
Querverweis: Binding   Dpathconf   Dopendir

5.11.2.1 Bindings für Pdomain

C: int16_t Pdomain ( int16_t dom );
Assembler:
move.w    dom,-(sp)    ; Offset 2
move.w    #281,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #4,sp        ; Stack korrigieren

5.11.3 Pexec

Name: »program execution« - Programm laden und ausführen.
Gemdosnummer: 75
Deklaration: int32_t Pexec ( uint16_t mode, ... );
Beschreibung: Die Funktion lädt und startet ein Programm. Über den Parameter mode lassen sich verschiedene Varianten auswählen:
mode Bedeutung
0 int32_t Pexec (0, int8_t *name, int8_t *cmdline, int8_t *env);

Load and go: Lädt und startet das in name angegebene Programm, und übergibt die Kommandozeile cmdline. Für den Parameter env gilt:
-1 = kein Environment anlegen.
NULL = Environment des Parent vererben.



Jeder andere Wert ist ein Zeiger auf das zu vererbene Environment.
3 PD *Pexec (3, int8_t* name, int8_t *cmdline, int8_t *env);


Load, don't go: wird meist zum Starten von Overlays oder zum Laden von Programmen in einem Debugger benutzt. Entspricht mode 0, mit dem Unterschied, daß das Programm nicht sofort gestartet wird, sondern ein Zeiger auf die Basepage als LONG zurückgeliefert wird. Der Parent ist der Eigentümer des Speichers, den die Basepage und das Environment des Childs belegen und muß ihn freigeben, wenn das Child sich beendet hat.
4 int32_t Pexec (4, 0L, PD *basepage, 0L);


Just go: startet ein bereits geladenes Programm. Die Basepage sollte mit mode 3 oder 5 erzeugt worden sein.
5 PD *Pexec (5, 0L, int8_t *cmdline, int8_t *env);


Create Basepage: Zunächst legt GEMDOS ein neues Environment an. Dann wird der größte zusammenhängende Speicherblock alloziert und in den ersten 256 Byte eine Basepage angelegt. Für den Parameter env gilt:
-1 = kein Environment anlegen.
NULL = Environment des Parent vererben.



Jeder andere Wert ist ein Zeiger auf das zu vererbende Environment.

Unter MiNT kann dieser Mode zusammen mit mode 3 dazu benutzt werden, einen Aufruf von Pvfork ohne Blockieren des parent zu emulieren.
6 int32_t Pexec (6, 0L, PD *basepage, 0L);


Just go, then free: Entspricht mode 4, mit dem Unterschied, daß allozierter Speicher dem gestarteten Prozess und nicht dem Starter gehört, so daß der Speicher, den die Basepage belegt, automatisch freigegeben wird, wenn das Child mit Pterm terminiert. Zusammen mit Modus 3 kann damit der gleiche Effekt erzielt werden, wie durch Modus 0. Dieser Modus steht erst ab GEMDOS-Version 0.15 zur Verfügung.
7 PD *Pexec (7, uint32_t prgflags, int8_t *cmdline, int8_t *env);

Create Basepage, respecting prgflags: Analog mode 5, nur kann in prgflags die gleiche Information wie im Feld ph_prgflags des Programm-Headers übergeben werden. Dieser Modus wird vom BIOS des TT benutzt, um GEM zu starten, und steht erst ab GEMDOS Version 0.19 zur Verfügung.
100 int32_t Pexec (100, int8_t *name, int8_t *cmdline, int8_t *env);

Load, go, don't wait: Analog mode 0, nur wartet der Aufrufer nicht, bis das gestartete Programm beendet wird, d.h. die Funktion kehrt sofort zum Parent Prozess zurück, während das Child startet. Der Rückgabewert ist ein negativer Fehlercode oder die positive PID des Childs.
101 da dieser Modus nur MagiC-intern zum Vererben von Pfad- und Dateihandles benutzt wird, wird auf die Angabe der genauen Syntax an dieser Stelle verzichtet.
102 wird MagiC-intern verwendet, um einen bestimmten Prozess zu entfernen. Auf die genaue Syntax wird daher an dieser Stelle verzichtet.
104 int32_t Pexec (104, int8_t *name, PD *basepage, 0L);


Just go, don't wait: Analog mode 4, nur wartet der Aufrufer nicht, bis das gestartete Programm beendet wird. Es wird ein Prozess gestartet, dessen Basepage vorher durch einen Modus von 3, 5 oder 7 gesetzt wurde. Zu beachten ist, daß das Environment und die Basepage des Childs sich auch im Besitz des Parents befinden (tatsächlich erbt der Child allen Speicher, der sich im Besitz des Parents befindet). Der Parameter name ist ein Zeiger auf einen String, der den Namen des neuen Prozesses beschreibt; bei einem NULL-Wert wird der Name des Parent-Prozesses benutzt. Die Funktion liefert einen negativen Fehlercode, oder die positive PID des Childs zurück.
106 int32_t Pexec (106, int8_t *name, PD *basepage, 0L);


Just go, don't wait, no sharing: Analog mode 104, allerdings befinden sich Environment und Basepage des Childs nicht im Besitz des Parents, und der Child hat keinen Zugriff auf Speicher, welcher dem Parent-Prozess zugeteilt wurde. Beim Beenden des Childs wird dessen Speicherplatz wieder freigegeben. In Verbindung mit Modus 3 entspricht Pexec (106, ...) daher dem Modus 100 (während Modus 3 gefolgt von Modus 6 einem Aufruf von Pexec (0, ...) entspricht).
Wird ab MagiC 2.0 nicht mehr unterstützt.
107 entspricht im wesentlichen mode 7, und wird intern von MagiC verwendet. Auf die genaue Syntax wird daher an dieser Stelle verzichtet.
108 wird von MagiC intern zum Starten eines Accessories verwendet. Da die genaue Syntax offiziell nicht dokumentiert ist, sollten eigene Programme besser auf shel_write zurückgreifen.
200 int32_t Pexec (200, int8_t *name, int8_t *cmdline, int8_t *env);

Replace program and go: Analog mode 100, jedoch überschreibt der neue Prozess den alten vollständig. Der alte Prozess behält zwar seine PID und die meisten seiner Attribute, aber sein gesamter Speicherplatz wird freigegeben. Während Pexec (0, ...) als Unterprogrammaufruf (call...return) angesehen werden kann, wirkt dieser Modus eher wie ein 'goto'.



Hinweis: Nicht alle Modi sind unter allen Betriebssystemvarianten verfügbar; deshalb sollte der Rückgabewert der Funktion beachtet werden. Unbekannte Modi sorgen für ein Funktionsergebnis von EINVFN.

Kommandozeilen werden als String im Pascal-Format übergeben, d.h. im ersten Byte befindet sich die Länge der Zeile (maximal 124 Zeichen).
Ergebnis: Die Funktion liefert als Ergebnis den Abschlußcode des Child-Prozesses. Wenn ein Overlay geladen wurde, enthält das Ergebnis die Basepage des Overlays. Bei einem negativen Resultat ist ein Fehler aufgetreten.
Verfügbar: Alle GEMDOS Versionen.
Gruppe: Prozessfunktionen
Querverweis: Binding   shel_write   Programmflags   ARGV-Verfahren

5.11.3.1 Bindings für Pexec

C: int32_t Pexec ( uint16_t mode, ... );
Assembler:
pea       env          ; Offset 12
pea       cmdline      ; Offset  8
pea       name         ; Offset  4
move.w    mode,-(sp)   ; Offset  2
move.w    #75,-(sp)    ; Offset  0
trap      #1           ; GEMDOS aufrufen
lea       $10(sp),sp   ; Stack korrigieren
GFA-Basic Adresse%=Gemdos(&H4B,W:mode%,L:name%,L:cmdline%,L:env)

5.11.4 Pfork

Name: »Pfork« - Kopie des aktuellen Prozesses erzeugen.
Gemdosnummer: 283
Deklaration: int16_t Pfork ( void );
Beschreibung: Die Funktion erzeugt eine Kopie des aktuellen Prozesses. Der Child-Prozeß erbt dabei eine Kopie des Adreßraums des Parent-Prozesses, d.h. Änderungen, die der Child an Variablen macht, haben keinen Einfluß auf den Parent.

Der neu erzeugte Prozeß beginnt seine Arbeit, wenn die Funktion Pfork zurückkehrt.

Wenn der Parent im Supervisor-Modus ist, wenn diese Funktion aufgerufen wird, wird das Child dennoch im User-Modus gestartet.

Ein neuer Prozess, der mit dieser Funktion gestartet wird, darf nicht Mshrink aufrufen, muß aber jede GEM Iinitialisierung wie appl_init und v_openvwk erneut ausführen (wenn er GEM benötigt). Parent und Child müssen beide Pterm oder Pterm0 aufrufen, um sich zu beenden.
Ergebnis: Die Funktion kann folgende Rückgabewerte liefern:
E_OK  : im Child-Prozeß.
>0    : neue Prozess-ID im Parent-Prozeß.
ENSMEM: nicht genug Speicher vorhanden, um den neuen Prozeß zu erzeugen.

Verfügbar: Seit der ersten in MultiTOS integrierten MiNT Version 1.04.
Gruppe: Prozessfunktionen
Querverweis: Binding   Pexec   Pvfork   Threads

5.11.4.1 Bindings für Pfork

C: int16_t Pfork ( void );
Assembler:
move.w    #283,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #2,sp        ; Stack korrigieren

5.11.5 Pgetauid

Name: »Pgetauid« - User ID eines Prozesses zu Beginn ermitteln.
Gemdosnummer: 326 (0x0145)
Deklaration: int16_t Pgetauid ( void );
Beschreibung: Die Funktion ermittelt die Anfangs-User-ID des aktuellen Prozesses. Zusammen mit Psetauid kann damit in einer Multiuserumgebung festgestellt werden, wer der zuerst eingeloggte Benutzer war.
Ergebnis: Der Rückgabewert ist die Anfangs-User-ID des Prozesses.
Verfügbar: ab MiNT 1.11
Gruppe: Prozessfunktionen
Querverweis: Binding   Psetauid

5.11.5.1 Bindings für Pgetauid

C: int16_t Pgetauid ( void );
Assembler:
move.w    #326,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #2,sp        ; Stack korrigieren

5.11.6 Pgetegid

Name: »Pgetegid« - effektive Gruppen-ID eines Prozesses ermitteln.
Gemdosnummer: 313
Deklaration: int32_t Pgetegid ( void );
Beschreibung: Die Funktion liefert die effektive Gruppen-ID des aktuellen Prozesses und ähnelt dem Systemaufruf Pgetgid. Der Unterschied besteht darin, daß hier die effektive Gruppen-ID zurückgegeben wird.

Diese ist normalerweise mit der wirklichen Gruppen-ID identisch; falls aber ein Programm läuft, welches das setgid Bit gesetzt hat, ist seine effektive Gruppen-ID gleich der (wirklichen) ID des Besitzers dieser Programmdatei.

Dateizugriff basiert u.a. auf der effektiven Gruppen-ID, so daß der setgid-Mechanismus es Benutzern (vor allem dem Super-User) erlaubt, anderen Usern Zugriff zu erlauben.
Ergebnis: Der Rückgabewert ist die effektive Gruppen-ID des Prozesses.
Verfügbar: Verfügbar, wenn ein 'MiNT' Cookie mit einer Versionsnummer von mindestens 0.95 existiert.
Gruppe: Prozessfunktionen
Querverweis: Binding   Pgetuid   Pgetgid   Pgeteuid

5.11.6.1 Bindings für Pgetegid

C: int32_t Pgetegid ( void );
Assembler:
move.w    #313,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #2,sp        ; Stack korrigieren

5.11.7 Pgeteuid

Name: »Pgeteuid« - effektive User-ID eines Prozesses ermitteln.
Gemdosnummer: 312
Deklaration: int32_t Pgeteuid ( void );
Beschreibung: Die Funktion liefert die effektive User-ID des aktuellen Prozesses und ähnelt dem Systemaufruf Pgetuid. Der Unterschied besteht darin, daß hier die effektive User-ID zurückgegeben wird.

Diese ist normalerweise mit der wirklichen User-ID identisch; falls aber ein Programm läuft, welches das setuid Bit gesetzt hat, ist seine effektive User-ID gleich der (wirklichen) ID des Besitzers dieser Programmdatei.

Dateizugriff basiert u.a. auf der effektiven User-ID, so daß der setuid-Mechanismus es Benutzern (vor allem dem Super-User) erlaubt, anderen Usern Zugriff zu erlauben.
Ergebnis: Der Rückgabewert ist die effektive User-ID des Prozesses.
Verfügbar: Verfügbar, wenn ein 'MiNT' Cookie mit einer Versionsnummer von mindestens 0.95 existiert.
Gruppe: Prozessfunktionen
Querverweis: Binding   Pgetuid   Pgetgid   Pgetegid

5.11.7.1 Bindings für Pgeteuid

C: int32_t Pgeteuid ( void );
Assembler:
move.w    #312,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #2,sp        ; Stack korrigieren

5.11.8 Pgetgid

Name: »Pgetgid« - Gruppen ID eines Prozesses ermitteln.
Gemdosnummer: 276
Deklaration: int16_t Pgetgid ( void );
Beschreibung: Die Funktion liefert die wirkliche Gruppen-ID des aktuellen Prozesses zurück. Dies ist eine Zahl zwischen 0 und 255, die die Rechte der Prozessgruppe festlegt.
Ergebnis: Der Rückgabewert ist die wirkliche Gruppen-ID des Prozesses.
Verfügbar: Seit der ersten in MultiTOS integrierten MiNT Version 1.04.
Gruppe: Prozessfunktionen
Querverweis: Binding   Pgetuid   Pgeteuid   Pgetegid

5.11.8.1 Bindings für Pgetgid

C: int16_t Pgetgid ( void );
Assembler:
move.w    #276,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #2,sp        ; Stack korrigieren

5.11.9 Pgetgroups

Name: »Pgetgroups« - gets the supplementary group ids for the calling process.
Gemdosnummer: 327 (0x0147)
Deklaration: int32_t Pgetgroups( int16_t len, int16_t *gidset);
Beschreibung: This function gets the supplementary group ids for the calling process.

len specifies the length (in words) of the array to be filled with the supplementary group ids available. This value must be a positive number not greater than NGROUPS_MAX. If len is a zero, the call will return the number of supplementary group ids currently available for the calling process.

gidset is a pointer to a word array to be filled with retrieved ids.

The NGROUPS_MAX value is returned by Sysconf().
Ergebnis: Returns a number of supplementary group ids for the process on success or a negative GEMDOS error code otherwise.
Verfügbar: Sie steht ab MiNT 1.11 zu Verfügung.
Gruppe: Prozessfunktionen
Querverweis: Binding   Psetgroups   Sysconf

5.11.9.1 Bindings für Pgetgroups

C: int32_t Pgetgroups( int16_t len, int16_t *gidset);
Assembler:
peam      gidset       ; Offset 4
move.w    len,-(sp)    ; Offset 2
move.w    #327,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #8,sp        ; Stack korrigieren

5.11.10 Pgetpgrp

Name: »Pgetpgrp« - aktuelle Prozess Gruppennummer erfragen.
Gemdosnummer: 269
Deklaration: int16_t Pgetpgrp ( void );
Beschreibung: Es wird die Gruppen-Nummer des aktuell aktiven Prozesses zurück geliefert. Prozessgruppen werden gewöhnlich für Job-Control und andere Zwecke benutzt.
Ergebnis: Prozeß-Gruppen-Nummer des aktiven Prozesses.
Verfügbar: Seit der ersten in MultiTOS integrierten MiNT Version 1.04.
Gruppe: Prozessfunktionen
Querverweis: Bindings für Pgetpgrp   Pkill   Pgetpid   Psetpgrp

5.11.10.1 Bindings für Pgetpgrp

C: int16_t Pgetpgrp ( void );
Assembler:
move.w    #269,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #2,sp        ; Stack korrigieren

5.11.11 Pgetpid

Name: »Pgetpid« - aktuelle Prozess ID erfragen.
Gemdosnummer: 267 (0x010b)
Deklaration: int16_t Pgetpid ( void );
Beschreibung: Die Funktion liefert die PID des aktuell aktiven Prozesses, also desjenigen, der momentan die CPU besitzt; es handelt sich dabei um den Dateityp, unter dem der aktuelle Prozess im Verzeichnis U:\PROC geführt wird.

A PID is dynamically assigned to a process when it is created. You should make no assumption on the PID a process may have. For the kernel, the PID is a WORD but when you program in C, you should use the pid_t type, which complies with the POSIX standard. The FreeMiNT kernel's PID is always 0.

The PID is useful when it is important to identify a process among others in the system. Knowing the PID of a program, it is possible to do a lot of things: send it a signal with Psignal(), look for its name in /proc by searching with a "*.xxx" mask (xxx is the PID of the program which name we wanna know), etc.
Ergebnis: PID des aktiven Prozesses.
Verfügbar: Sie steht in MagiC ab Version 3.0 und unter MiNT zur Verfügung.
Gruppe: Prozessfunktionen
Querverweis: Binding   Pgetpgrp   Pgetppid

5.11.11.1 Bindings für Pgetpid

C: int16_t Pgetpid ( void );
Assembler:
move.w    #267,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #2,sp        ; Stack korrigieren

5.11.12 Pgetppid

Name: »Pgetppid« - Prozess ID für Vater Prozess erfragen.
Gemdosnummer: 268 (0x010c)
Deklaration: int16_t Pgetppid ( void );
Beschreibung: Die Funktion liefert die PID des Parent-Prozesses, des z.Zt. aktiven Prozesses.

In the FreeMiNT kernel, processes are represented as a tree. The root of the tree is the kernel itself (PID 0). At boot time, the kernel launches another process (which can be 'init' in case of a Unix-like setup, or an AES, a shell or whatever) specified by the INIT or GEM keyword in the mint.cnf file. This process will launch other processes (daemons, accessories, programs etc) that are its so-called children.

Therefore, every process (but the kernel, obviously) is created by its so-called parent. The Pgetppid() (get parent's PID) call allows to determine the PID of the parent of the calling process. To have a good illustration of this, you can use the 'ps' command in your shell. You will see that all accessories's parent is the AES, and that the daemons are started by the 'init' program.
Ergebnis: Prozess-ID des Parent (positiv). Wenn der aktuelle Prozess direkt vom Kernel gestartet wurde, wird 0 zurück geliefert. Ein Rückgabewert von -1 signalisiert, daß der Prozess keinen Parent besitzt.
Verfügbar: Seit der ersten in MultiTOS integrierten MiNT Version 1.04 und MagiC ab Version 3.0.
Gruppe: Prozessfunktionen
Querverweis: Binding   Pgetpgrp   Pgetpid

5.11.12.1 Bindings für Pgetppid

C: int16_t Pgetppid ( void );
Assembler:
move.w    #268,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #2,sp        ; Stack korrigieren

5.11.13 Pgetpriority

Name: »Pgetpriority« - gets the current priority value for a process
Gemdosnummer: 344 (0x0158)
Deklaration: int32_t Pgetpriority ( int16_t which, int16_t who);
Beschreibung: This function gets the priority of the processes specified by which and who. The interpretation of parameter who depends on which:

PRIO_PROCESS (0) reads the priority of process with process id which. A who of 0 implies the process id of the calling process.

PRIO_PGRP (1) reads the priority of the process group with process group id who. If the priorities of the process differ, the lowest valued priority (i. e. the highest CPU usage priority) is returned. A who of 0 implies the process group id of the calling process.

PRIO_USER (2) reads the priority of the process of the user with user id who. For multiple processes the lowest valued priority is returned. A who of 0 implies the user id of the calling process.

Library functions should first check for an error condition and then decrement the returned value by 20.

This call makes calls Pnice and Prenice obsolete.
Ergebnis: Return value is either a negative error number in case of failure or the requested priority + 20 on success.
Verfügbar: MiNT 1.15.0
Gruppe: Prozessfunktionen
Querverweis: Binding   Psetpriority

5.11.13.1 Bindings für Pgetpriority

C: int32_t Pgetpriority ( int16_t which, int16_t who);
Assembler:
move.w    who,-(sp)    ; Offset 4
move.w    which,-(sp)  ; Offset 2
move.w    #344,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #6,sp        ; Stack korrigieren

5.11.14 Pgetuid

Name: »Pgetuid« - User ID eines Prozesses ermitteln.
Gemdosnummer: 271
Deklaration: int16_t Pgetuid ( void );
Beschreibung: Die Funktion liefert die wirkliche User-ID des aktuellen Prozesses zurück. Dies ist eine Zahl zwischen 0 und 255, die die Zugriffsrechte des Prozesses festlegt und benutzt werden kann, um in Multi-User-Systemen die einzelnen Benutzer zu unterscheiden.
Ergebnis: Der Rückgabewert ist die tatsächliche User-ID des Prozesses.
Verfügbar: Seit der ersten in MultiTOS integrierten MiNT Version 1.04.
Gruppe: Prozessfunktionen
Querverweis: Binding   Pgetgid   Pgeteuid   Pgetegid

5.11.14.1 Bindings für Pgetuid

C: int16_t Pgetuid ( void );
Assembler:
move.w    #271,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #2,sp        ; Stack korrigieren

5.11.15 Pkill

Name: »Pkill« - Signal zu einem Prozess schicken.
Gemdosnummer: 273
Deklaration: int16_t Pkill ( int16_t pid, int16_t sig );
Beschreibung: Die Funktion sendet das Signal sig an einen oder mehrere Prozesse. Für den Parameter pid gilt:
pid Bedeutung
   
> 0 das Signal wird dem Prozess mit der angegebenen pid geschickt.
= 0 das Signal wird an alle Prozesse der entsprechenden Prozessgruppe geschickt (dazu gehört auch der Aufrufer selbst !).
< 0 das Signal wird an alle Prozesse mit der Gruppennummer -pid geschickt.



Das Signal SIGNULL wird von Pkill nicht in der gewohnten Weise behandelt. Es kann benutzt werden, um die Existenz eines Prozesses zu testen. Dazu schickt man diesem ein SIGNULL, und kontrolliert, ob Pkill mit dem Wert 0 zurückkehrt.

MagiC unterstützt nur PIDs > 0.
Ergebnis: Die Funktion kann folgende Rückgabewerte liefern:
E_OK  : kein Fehler aufgetreten.
EFILNF: falls pid > 0 und der angegebene Prozess nicht mehr existiert bzw. falls pid < 0 und die angegebene Prozeßgruppe keine Mitglieder mehr besitzt.
EACCDN: falls pid > 0, und der sendende Prozess keine EUID von 0 besitzt und außerdem die UID des empfangenden von der des sendenden Prozesses abweicht.
ERANGE: sig ist kein gültiges Signal.



Hinweis: Wenn der aktuelle Prozess das Signal selbst empfängt und terminiert wird, kehrt die Funktion nicht zurück!
Verfügbar: Seit der ersten in MultiTOS integrierten MiNT Version 1.04 und MagiC ab Version 4.50.
Gruppe: Prozessfunktionen
Querverweis: Binding   Psetpgrp   Psignal   Signale

5.11.15.1 Bindings für Pkill

C: int16_t Pkill ( int16_t pid, int16_t sig );
Assembler:
move.w    sig,-(sp)    ; Offset 4
move.w    pid,-(sp)    ; Offset 2
move.w    #273,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #6,sp        ; Stack korrigieren

5.11.16 Pmsg

Name: »Pmsg« - Empfangen und Senden von Nachrichten.
Gemdosnummer: 293
Deklaration: int32_t Pmsg ( int16_t mode, int32_t mbox, void *msg );
Beschreibung: Die Funktion sendet bzw. empfängt eine Nachricht zu bzw. von einer Mailbox. Die jeweils auszuführende Operation kann über die Bits des Parameters mode festgelegt werden. Es bedeutet:
mode Operation
   
0x0000 Blockiert den Prozess bis aus der übergebenen Mailbox mit der ID mbox eine Nachricht gelesen werden kann und speichert diese in der Struktur, auf die msg zeigt.
0x0001 Blockiert den Prozess bis ein Prozess auf eine Nachricht aus der Mailbox mit der ID mbox wartet und diese Nachricht aus der Struktur, auf die msg zeigt, ausliest.
0x0002 Blockiert den Prozess bis ein Prozess auf eine Nachricht aus der Mailbox mit der ID mbox wartet und diese Nachricht aus der Struktur, auf die msg zeigt, ausliest und in der Mailbox mit der Kennung 0xffffxxxx eine Nachricht liegt (dabei ist xxxx die PID des aktuellen Prozesses).
0x8000 Durch eine ODER-Verknüpfung mit diesem Wert kann die Operation im nicht-blockierenden Modus ausgeführt werden.



Die Nachrichten sind 5 Wörter lang, und zwar zwei Langworte und ein Short (in dieser Reihenfolge). Dabei können die 2 Langwörter vom Prozess mit beliebiger Information gefüllt werden, während im Short die PID des Senders einzutragen ist.

Nach dem die Nachricht verschickt worden ist, enthält dieses Short die PID des Prozesses, der die Nachricht gelesen hat. Umgekehrt enthält dieser nach dem Lesen einer Nachricht die PID des Prozesses, der die Nachricht geschrieben hat.

Wenn in mode das höchstwertige Bit gesetzt ist, und es keinen Leser bzw. Schreiber für die Mailbox mbox gibt, wird der Wert -1 zurückgeliefert. Anderenfalls wartet eine Leseoperation bis eine Nachricht geschrieben wurde, bzw. eine Schreiboperation bis ein lesender Prozess bereit ist.

Im Modus 2 gibt der Schreiber an, daß er auf eine Antwort warten möchte. Die Idee dabei ist, daß dieser Prozess sich schlafen legen kann, und zu einem späteren Zeitpunkt von dem Prozess der die Nachricht erhält, wieder aufgeweckt werden kann. Dabei wird garantiert, daß der Prozess, welcher die Original-Nachricht erhält beim Schreiben der Antwort nicht blockiert wird.
Ergebnis: Die Funktion kann folgende Rückgabewerte liefern:
E_OK : kein Fehler aufgetreten.
EINVFN : ungültiger Wert für den Parameter mode.
-1 : Bit-15 ist gesetzt, und Pmsg würde blockieren.

Verfügbar: Verfügbar, wenn ein 'MiNT' Cookie mit einer Versionsnummer von mindestens 0.90 existiert.
Gruppe: Prozessfunktionen
Querverweis: Binding

5.11.16.1 Bindings für Pmsg

C: int32_t Pmsg ( int16_t mode, int32_t mbox, void *msg );
Assembler:
pea       msg          ; Offset 8
move.l    mbox,-(sp)   ; Offset 4
move.w    mode,-(sp)   ; Offset 2
move.w    #293,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
lea       $C(sp),sp    ; Stack korrigieren

5.11.17 Pnice

Name: »Pnice« - Priorität des aktuellen Prozesses verändern.
Gemdosnummer: 266
Deklaration: int16_t Pnice ( int16_t delta );
Beschreibung: Die Funktion ändert die Priorität des aktuellen Prozesses um den Wert delta. Eine höhere Priorität bedeutet, daß der Prozess eine größere Zeitscheibe erhält, also nicht so oft umgeschaltet wird. Analog bedeutet eine niedrige Priorität, daß die Zeitscheibe des Prozesses verkleinert wird, und er daher öfter die CPU abgeben muß.

Für den Parameter delta muß gelten:
- 20 <= delta <= 20.

Die Funktion Pnice entspricht Prenice (Pgetpid(), delta) und ist zur Abwärtskompatibilität implementiert.
Ergebnis: Die Funktion liefert die aktuelle Prozeß Umschalt-Priorität zurück. Diese ist per Default auf 0 eingestellt. Größere bzw. kleinere Werte bedeuten, daß der Prozess eine größere bzw. kleinere Zeitscheibe besitzt.
Verfügbar: Seit der ersten in MultiTOS integrierten MiNT Version 1.04.
Gruppe: Prozessfunktionen
Querverweis: Binding   Prenice

5.11.17.1 Bindings für Pnice

C: int16_t Pnice ( int16_t delta );
Assembler:
move.w    delta,-(sp)  ; Offset 2
move.w    #266,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #4,sp        ; Stack korrigieren

5.11.18 Prenice

Name: »Prenice« - Priorität eines Prozesses verändern.
Gemdosnummer: 295
Deklaration: int32_t Prenice ( int16_t pid, int16_t delta );
Beschreibung: Die Funktion ändert die Priorität des Prozesses mit der Kennung pid um den Wert delta. Eine höhere Priorität bedeutet, daß der Prozess eine größere Zeitscheibe erhält, also nicht so oft umgeschaltet wird. Analog bedeutet eine niedrige Priorität, daß die Zeitscheibe des Prozesses verkleinert wird, und er daher öfter die CPU abgeben muß.

Für den Parameter delta muß gelten:
- 20 <= delta <= 20.
Ergebnis: Die Funktion liefert die aktuelle Prozeß Umschalt-Priorität zurück. Diese ist per Default auf 0 eingestellt. Größere bzw. kleinere Werte bedeuten, daß der Prozess eine größere bzw. kleinere Zeitscheibe besitzt.

Im Fehlerfall liefert die Funktion:
EFILNF: der angegebene Prozess existiert nicht.
EACCDN: der angegebene Prozess besitzt eine andere User-ID als der aufrufende Prozess.

Verfügbar: Verfügbar, wenn ein 'MiNT' Cookie mit einer Versionsnummer von mindestens 0.90 existiert.
Gruppe: Prozessfunktionen
Querverweis: Bindings für Prenice   Pnice

5.11.18.1 Bindings für Prenice

C: int32_t Prenice ( int16_t pid, int16_t delta );
Assembler:
move.w    delta,-(sp)  ; Offset 4
move.w    pid,-(sp)    ; Offset 2
move.w    #295,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #6,sp        ; Stack korrigieren

5.11.19 Prusage

Name: »Prusage« - Informationen über Resourcenverbrauch ermitteln.
Gemdosnummer: 286
Deklaration: void Prusage ( int32_t *r );
Beschreibung: Die Funktion liefert Informationen über den Bedarf an Systemresourcen des aktuellen Prozesses.

Die Informationen werden im Array r nach außen gereicht; es gilt folgende Belegung:
r[0]: Prozess-Zeit im Kernel
r[1]: Prozess-Zeit im eigenen Programmcode
r[2]: Gesamt-Prozesszeit der Childs im Kernel
r[3]: Gesamt-Prozesszeit der Childs im eigenen Programmcode
r[4]: Speicher der diesem Prozess gehört (in Bytes)
r[5]: reserviert
r[6]: reserviert
r[7]: reserviert



Alle Zeiten sind in Milli-Sekunden angegeben.
Ergebnis: Die Funktion hat kein direktes Ergebnis.
Verfügbar: Seit der ersten in MultiTOS integrierten MiNT Version 1.04.
Gruppe: Prozessfunktionen
Querverweis: Binding   Psetlimit

5.11.19.1 Bindings für Prusage

C: void Prusage ( int32_t *r );
Assembler:
pea       r            ; Offset 2
move.w    #286,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #6,sp        ; Stack korrigieren

5.11.20 Psemaphore

Name: »Psemaphore« - erzeugen, anwenden, zerstören einer Semaphore.
Gemdosnummer: 308
Deklaration: int32_t Psemaphore ( int16_t mode, int32_t id, int32_t timeout );
Beschreibung: Die Funktion implementiert nicht-zählende Semaphore. Nur ein Prozess kann einen Semaphor zur gleichen Zeit besitzen.

Semaphoren können z.B. benutzt werden, um den Zugriff auf Datenstrukturen im Shared Memory von unterschiedlichen Teilprozessen zu synchronisieren: So muß ein Teilprozess, bevor er auf den Speicher zugreift, versuchen, in den Besitzt des Semaphors zu kommen. Dieser kann z.B. bei der Initialisierung erzeugt, und bei Programmende wieder entfernt werden.

Semaphore werden durch einen Namen identifiziert. Dieser Name ist ein Langwort, das auch vier ASCII-Zeichen enthalten kann. Semaphore, deren Namen mit dem Unterstrich '_' beginnen sind dabei für das Betriebssystem reserviert.

Der Parameter timeout wird nur im Modus 2 benutzt. Es gilt dabei die folgende Belegung:
timeout =  0: sofort zurückkehren
  = -1: kein Timeout (Forever).



Andere Werte für timeout geben die Wartezeit in Millisekunden an, bevor ein Timeout eintritt.

Für den Parameter mode sind folgende Werte möglich:
mode Bedeutung
   
0 Semaphore mit Kennung id erzeugen (und besitzen).
1 Semaphore mit Kennung id entfernen. Dies klappt nur, wenn der Aufrufer die Semaphore besitzt.
2 Besitz der Semaphore mit Kennung id beantragen. Dies blockiert den Aufrufer bis die Semaphore frei wird, oder ein Timeout eintritt.
3 Semaphore mit Kennung id freigeben. Dies klappt nur, wenn der Aufrufer die Semaphore besitzt.



Hinweis: Wenn ein Prozess eine Semaphore erzeugt, besitzt er sie auch sofort. Damit andere Prozesse diese nutzen können, muß sie zunächst freigegeben werden. Da für das Erzeugen einer Semphore interner Speicher angefordert werden muss, sollte die Funktion sparsam verwendet werden.

Wenn ein blockierter Prozess auf eine Semaphore wartet (bevor der Timeout eintritt), und ein anderer Prozess entfernt die Semaphore, dann kehrt die Funktion Psemaphore mit der Meldung ERANGE zurück, da die angeforderte Semaphore nicht länger existiert.

Wenn ein Prozess terminiert, werden alle Semaphore die er besitzt, automatisch freigegeben (aber nicht zerstört). Der Besitz einer Semaphore kann nicht vererbt werden (etwa mit Pfork). Wenn ein Prozess eine Semaphore erzeugt und dann abstürzt, bleibt die Semaphore erhalten, und kann nicht mehr entfernt werden.

In MagiC sorgen Plausibilitätsüberprüfungen dafür, daß keine System-Semaphoren freigegeben werden können; außerdem werden z.Zt. nur die Modi 2 und 3 unterstützt.
Ergebnis: Die Funktion kann folgende Rückgabewerte liefern:
E_OK  : kein Fehler aufgetreten.
ERROR : es wurde eine Semaphore beantragt, die der Antragsteller bereits besitzt.
EACCDN: es wurde versucht eine Semaphore zu erzeugen, die bereits existiert, der Aufrufer ist nicht im Besitz der Semaphore oder ein Timeout ist eingetreten.
ERANGE: der angegebene Semaphor existiert nicht.

Verfügbar: Verfügbar, wenn ein 'MiNT' Cookie mit einer Versionsnummer von mindestens 0.92 existiert und in MagiC ab Version 3.0.
Gruppe: Prozessfunktionen
Querverweis: Binding   Semaphoren in MagiC

5.11.20.1 Bindings für Psemaphore

C: int32_t Psemaphore ( int16_t mode, int32_t id, int32_t timeout );
Assembler:
move.l    timeout,-(sp)  ; Offset 8
move.l    id,-(sp)       ; Offset 4
move.w    mode,-(sp)     ; Offset 2
move.w    #308,-(sp)     ; Offset 0
trap      #1             ; GEMDOS aufrufen
lea       $C(sp),sp      ; Stack korrigieren

5.11.21 Psetauid

Name: »Psetauid« - User ID eines Prozesses zu Beginn setzen.
Gemdosnummer: 325 (0x0146)
Deklaration: int16_t Psetauid ( int16_t id );
Beschreibung: Die Funktion setzt die Anfangs-User-ID des aktuellen Prozesses. Dies kann nur einmal geschehen. Zusammen mit Pgetauid kann damit in einer Multiuser-Umgebung festgestellt werden, wer der zuerst eingeloggte Benutzer war. Der Parameter id ist die gewünschte Anfangs-ID.

Achtung: Diese Funktion ist optional, daher darf ein Aufruf mit EINVFN beantwortet werden.
Ergebnis: z.Zt. unbekannt
Verfügbar: Verfügbar, wenn ein 'MiNT' Cookie mit einer Versionsnummer von mindestens 0.92 existiert.
Gruppe: Prozessfunktionen
Querverweis: Binding   Pgetauid

5.11.21.1 Bindings für Psetauid

C: int16_t Psetauid ( int16_t id );
Assembler:
move.w    id,-(sp)     ; Offset 2
move.w    #325,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #4,sp        ; Stack korrigieren

5.11.22 Psetegid

Name: »Psetegid« - sets the effective group id for the calling process.
Gemdosnummer: 324 (0x0144)
Deklaration: int32_t Psetegid ( int16_t egid );
Beschreibung: egid specifies the new effective group id for the calling process.

Prior to MiNT version 1.12 this call contained a bug affecting its functionality. Setting effective group id needs root privileges.

This call is often used by daemon processes to downgrade their privileges to user level.
Ergebnis: Returns new egid on success or a negative GEMDOS error code otherwise.
Verfügbar: MiNT 1.11
Gruppe: Prozessfunktionen
Querverweis: Binding   Pseteuid   Psetgid   Psetregid

5.11.22.1 Bindings für Psetegid

C: int32_t Psetegid ( int16_t egid );
Assembler:
move.w    egid,-(sp)   ; Offset 2
move.w    #324,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #4,sp        ; Stack korrigieren

5.11.23 Pseteuid

Name: »Pseteuid« - sets the effective user id for the calling process.
Gemdosnummer: 323 (0x0143)
Deklaration: int32_t Pseteuid ( int16_t euid );
Beschreibung: euid specifies the new effective user id for the calling process.

Prior to MiNT version 1.12 this call contained a bug affecting its functionality. Setting effective user id needs root privileges.

This call is often used by daemon processes to downgrade their privileges to user level.
Ergebnis: Returns new euid on success or a negative GEMDOS error code otherwise.
Verfügbar: ab MiNT 1.11
Gruppe: Prozessfunktionen
Querverweis: Binding   Psetegid   Psetuid   Psetreuid

5.11.23.1 Bindings für Pseteuid

C: int32_t Pseteuid ( int16_t euid );
Assembler:
move.w    euid,-(sp)   ; Offset 2
move.w    #323,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #4,sp        ; Stack korrigieren

5.11.24 Psetgid

Name: »Psetgid« - Gruppen ID eines Prozesses verändern.
Gemdosnummer: 277
Deklaration: int16_t Psetgid ( int16_t id );
Beschreibung: Die Funktion setzt die Gruppen-ID des aktuellen Prozesses auf id. Dies muß eine Zahl von 0 bis 255 sein.
Ergebnis: Die Funktion kann folgende Rückgabewerte liefern:
0-255 : kein Fehler aufgetreten (die neue ID).
EACCDN: der Prozess hat keine Berechtigung, seine ID zu verändern.

Verfügbar: Seit der ersten in MultiTOS integrierten MiNT Version 1.04.
Gruppe: Prozessfunktionen
Querverweis: Binding   Psetuid

5.11.24.1 Bindings für Psetgid

C: int16_t Psetgid ( int16_t id );
Assembler:
move.w    id,-(sp)     ; Offset 2
move.w    #277,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #4,sp        ; Stack korrigieren

5.11.25 Psetgroups

Name: »Psetgroups« - sets the supplementary group ids for the calling process.
Gemdosnummer: 328 (0x0148)
Deklaration: int32_t Psetgroups( int16_t len, int16_t *gidset);
Beschreibung: This function sets the supplementary group ids for the calling process.

len specifies the length (in words) of the array containing the supplementary group ids to be set. This value must be a positive number not greater than NGROUPS_MAX. If len is a zero, the call will return the number of supplementary group ids those have been set.

gidset is a pointer to a word array containing the new supplementary group ids for the process.

Setting new supplementary group ids needs root privileges.

The NGROUPS_MAX value is returned by Sysconf().
Ergebnis: Returns a number of new supplementary group ids for the process on success or a negative GEMDOS error code otherwise.
Verfügbar: Sie steht ab MiNT 1.11 zu Verfügung.
Gruppe: Prozessfunktionen
Querverweis: Binding   Pgetgroups   Sysconf

5.11.25.1 Bindings für Psetgroups

C: int32_t Psetgroups( int16_t len, int16_t *gidset);
Assembler:
peam      gidset       ; Offset 4
move.w    len,-(sp)    ; Offset 2
move.w    #328,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #8,sp        ; Stack korrigieren

5.11.26 Psetlimit

Name: »Psetlimit« - Limits der Systemresourcen setzen/erfragen.
Gemdosnummer: 287
Deklaration: int32_t Psetlimit ( int16_t lim, int32_t value );
Beschreibung: Die Funktion dient dem Setzen/Abfragen einer Resourcenbegrenzung für den aktuellen Prozess. Der Parameter lim bestimmt die gewünschte Resource-Art:
lim Bedeutung
   
1 max. CPU-Zeit für den Prozess (Millisekunden)
2 max. Gesamtspeicher des Prozesses in Bytes
3 max. allozierbarer Speicher für den Prozess (in Bytes).



Der Unterschied zwischen 2 und 3 besteht darin, daß der Gesamtspeicher auch die TEXT-, DATA- und BSS-Segmente des Prozesses umfaßt.

Mit Hilfe dieser Funktion werden die Resource-Begrenzungen sowohl für den aktuellen Prozess, als auch für alle später erzeugten Childs einzeln eingestellt. Wenn ein Prozess also ein CPU-Limit einstellt, und danach mehrere Child-Prozesse erzeugt, dann gilt dieses CPU-Limit auch für jeden einzelnen Child, und nicht etwa für alle Childs zusammen.

Der Parameter value bestimmt den Wert, den eine Resource annehmen soll. Ein Wert von 0 bedeutet in diesem Zusammenhang, daß die Resource unbegrenzt ist. Ein negativer Wert läßt die Resource unverändert.

Hinweis: Es gibt keine Restriktionen beim Vergrößern der Begrenzungen. Jeder Prozess kann jede seiner Begrenzungen beliebig verändern oder sogar auf unbegrenzt setzen.

Speicherbegrenzungen kommen bei Pexec nicht zur Anwendung. Ist z.B. ein Prozess auf 256Kbyte begrenzt, kann er dennoch mit Pexec einen Tochterprozess starten, der mehr Speicher verbraucht. Achtung: Dies gilt nicht in MagiC; hier werden Speicherbegrenzungen bei Pexec vererbt!

Speicherbegrenzungen sind nicht rückwirkend gültig. Besitzt ein Prozess z.B. 256Kbyte und ruft dann Psetlimit auf, um seinen Bedarf auf 128Kbyte zu reduzieren, dann wird er zwar nicht beendet, aber er kann keinen Speicher mehr allozieren, bis seine Größe unter die angegebenen 128Kbyte fällt.

Begrenzungen der CPU-Zeit wirken hingegen rückwirkend. Verkürzt ein Prozess seine CPU-Zeit unter den bisher gültigen Wert, dann empfängt er sofort ein SIGXCPU-Signal.

Achtung: Ungültige Funktionsnummern und solche, die von MagiC nicht unterstützt werden, liefern EINVFN.

Hinweis zu MagiC: Ist ein Programm mit dem Dienstprogramm LIMITMEM modifiziert worden, hat diese Einstellung Vorrang vor dem Speicherlimit des aufrufenden Prozesses. Psetlimit wird vom erweiterten shel_write()-Modus unterstützt; damit können speicherbeschränkte Applikationen auch parallel gestartet werden.
Ergebnis: Die Funktion liefert den alten Begrenzungswert zurück.
Verfügbar: MagiC ab Version 4.0 (17.09.1996) und ab der ersten in MultiTOS integrierten MiNT Version 1.04.
Gruppe: Prozessfunktionen
Querverweis: Binding   Prusage   Signale

5.11.26.1 Bindings für Psetlimit

C: int32_t Psetlimit ( int16_t lim, int32_t value );
Assembler:
move.l    value,-(sp)  ; Offset 4
move.w    lim,-(sp)    ; Offset 2
move.w    #287,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #8,sp        ; Stack korrigieren

5.11.27 Psetpgrp

Name: »Psetpgrp« - Prozess Gruppennummer eines Prozesses setzen.
Gemdosnummer: 270
Deklaration: int16_t Psetpgrp ( int16_t pid, int16_t newgrp );
Beschreibung: Die Funktion verändert die Gruppennummer des Prozesses mit der Kennung pid auf den Wert newgrp. Der Prozess muß die gleiche UID wie der aktuelle Prozess besitzen, oder dessen Parent sein.

Falls pid = 0 ist, wird die Prozessgruppe des aktuellen Prozesses gesetzt. Falls newgrp = 0 ist, wird die Prozessgruppe auf den Wert der PID des aktuellen Prozesses gesetzt.
Ergebnis: Die Funktion kann folgende Rückgabewerte liefern:
>= 0  : kein Fehler (neue Prozessgruppen-Nummer).
EFILNF: der Prozess pid existiert nicht.
EACCDN: der Prozess pid besitzt eine andere UID, und ist kein Child des aufrufenden Prozesses.

Verfügbar: Seit der ersten in MultiTOS integrierten MiNT Version 1.04.
Gruppe: Prozessfunktionen
Querverweis: Binding   Pkill   Pgetpgrp   Pgetpid

5.11.27.1 Bindings für Psetpgrp

C: int16_t Psetpgrp ( int16_t pid, int16_t newgrp );
Assembler:
move.w    newgrp,-(sp)  ; Offset 4
move.w    pid,-(sp)     ; Offset 2
move.w    #270,-(sp)    ; Offset 0
trap      #1            ; GEMDOS aufrufen
addq.l    #6,sp         ; Stack korrigieren

5.11.28 Psetpriority

Name: »Psetpriority« - sets the current priority value for a process.
Gemdosnummer: 345 (0x0159)
Deklaration: int32_t Psetpriority ( int16_t which, int16_t who, int16_t pri );
Beschreibung: This function sets the priority pri (not an increment but an absolute value) for the processes specified by which and who. The interpretation of parameter who depends on which:

PRIO_PROCESS (0) sets the priority of process with process id which. A who of 0 implies the process id of the calling process.

PRIO_PGRP (1) sets the priority of the process group with process group id who. A who of 0 implies the process group id of the calling process.

PRIO_USER (2) sets the priority of the process of the user with user id who. A who of 0 implies the user id of the calling process.

The pri argument is silently changed to the maximum (resp. minimum) possible value if it is not in the range between PRIO_MIN (-20) and PRIO_MAX (+20).

This call makes calls Pnice and Prenice obsolete.
Ergebnis: The function returns E_OK on success or a negative error code otherwise. The following error conditions are defined:

EINVAL, invalid argument for who, which or pri.

EACCES, the calling process is not an owner of one or more of the selected processes. The other selected processes are still affected. EPERM, the calling process does not have privileges to change the priority of one or more of the selected processes. This can only happen if an attempt was made to change the priority of a process to a positive value.

ESRCH, the combination of which and who does not match any existing process.

The error condition reported is the last error condition encountered (in other words if both EACCES and EPERM occur the return value is arbitrary).
Verfügbar: ab MiNT 1.15.0
Gruppe: Prozessfunktionen
Querverweis: Binding   Pgetpriority

5.11.28.1 Bindings für Psetpriority

C: int32_t Psetpriority ( int16_t which, int16_t who, int16_t pri );
Assembler:
move.w    pri,-(sp)    ; Offset 6
move.w    who,-(sp)    ; Offset 4
move.w    which,-(sp)  ; Offset 2
move.w    #345,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #8,sp        ; Stack korrigieren

5.11.29 Psetregid

Name: »Psetregid« - sets the real and/or effective group id for the calling process.
Gemdosnummer: 335 (0x014f)
Deklaration: int32_t Psetregid ( int16_t rgid, int16_t egid);
Beschreibung: This function sets the real and/or effective group id for the calling process.

rgid specifies the new real group id and egid specifies the new effective group id for the calling process. If either argument is -1, only the other gets changed

Setting group ids needs root privileges.

This call is often used by daemon processes to downgrade their privileges to user level.
Ergebnis: Returns E_OK on success or a negative error code otherwise.
Verfügbar: since MiNT 1.12
Gruppe: Prozessfunktionen
Querverweis: Binding   Psetreuid   Psetegid

5.11.29.1 Bindings für Psetregid

C: int32_t Psetregid ( int16_t rgid, int16_t egid);
Assembler:
move.w    egid,-(sp)   ; Offset 4
move.w    rgid,-(sp)   ; Offset 2
move.w    #335,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #6,sp        ; Stack korrigieren

5.11.30 Psetreuid

Name: »Psetreuid« - sets the real and/or effective user id for the calling process.
Gemdosnummer: 334 (0x014e)
Deklaration: int32_t Psetreuid ( int16_t ruid, int16_t euid);
Beschreibung: This function sets the real and/or effective user id for the calling process.

ruid specifies the new real user id and euid specifies the new effective user id for the calling process. If either argument is -1, only the other gets changed.

Setting user ids needs root privileges.

This call is often used by daemon processes to downgrade their privileges to user level.
Ergebnis: Returns E_OK on success or a negative GEMDOS error code otherwise.
Verfügbar: since MiNT 1.12
Gruppe: Prozessfunktionen
Querverweis: Binding   Psetregid   Pseteuid

5.11.30.1 Bindings für Psetreuid

C: int32_t Psetreuid ( int16_t ruid, int16_t euid);
Assembler:
move.w    euid,-(sp)   ; Offset 4
move.w    ruid,-(sp)   ; Offset 2
move.w    #334,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #6,sp        ; Stack korrigieren

5.11.31 Psetuid

Name: »Psetuid« - User ID eines Prozesses verändern.
Gemdosnummer: 272
Deklaration: int16_t Psetuid ( int16_t id );
Beschreibung: Die Funktion setzt die User ID des aktuellen Prozesses auf id. Dies muß eine Zahl von 0 bis 255 sein. Die Funktion schlägt fehl, wenn die User-ID des Prozesses nicht den Wert 0 besitzt, d.h. einmal gesetzt, kann die User-ID nicht mehr verändert werden.
Ergebnis: Die Funktion kann folgende Rückgabewerte liefern:
0-255 : kein Fehler aufgetreten (die neue ID).
EACCDN: der Prozess hat keine Berechtigung, seine ID zu verändern.

Verfügbar: Seit der ersten in MultiTOS integrierten MiNT Version 1.04.
Gruppe: Prozessfunktionen
Querverweis: Binding   Psetgid

5.11.31.1 Bindings für Psetuid

C: int16_t Psetuid ( int16_t id );
Assembler:
move.w    id,-(sp)     ; Offset 2
move.w    #272,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #4,sp        ; Stack korrigieren

5.11.32 Psigaction

Name: »Psigaction« - Art der Signalbehandlung verändern.
Gemdosnummer: 311
Deklaration: int32_t Psigaction ( int16_t sig, struct sigaction *act, struct sigaction *oact );
Beschreibung: Die Funktion ändert die Art und Weise, wie auf das Signal sig reagiert werden soll. Der Parameter act ist dabei entweder NULL, oder zeigt auf eine sigaction-Struktur, die das Verhalten des Signal-Handlings beschreibt. Für die Komponente sa_handler gilt dabei:
sa_handler Bedeutung
   
0 beim Eintreffen des Signals wird die Default-Aktion für das Signal ausgeführt.
1 das Signal sig wird ignoriert. Liegt es gerade an, so wird es gelöscht.



Jeder andere Wert von sa_handler wird als die Adresse einer Funktion interpretiert, die beim Auftreten des Signals aufgerufen wird. Über den Stack wird dieser Funktion ein Long-Wert übergeben, der der jeweiligen Signalnummer entspricht. Auf diese Art und Weise ist es möglich, den Signal-Handler für mehrere Signale zu benutzen.

Solange ein Signal bearbeitet wird, kann es nicht erneut gesendet werden. Zu beachten ist ferner, daß (im Gegensatz zu einigen Unix-Versionen) das Signal-Handling vor der Ausführung des Handlers nicht auf den Default-Handler zurückgesetzt wird.

Der Signalhandler muß entweder mit RTS (Return to Sender) beendet werden, oder Psigreturn aufrufen, um anzuzeigen, daß die Signalbehandlung abgeschlossen ist. Anschließend wird die Blockierung des Signals aufgehoben. Psigreturn führt zusätzlich einige interne Säuberungen des Kernels durch, die notwendig sind, falls der Signal-Handler nicht beendet wird (longjump).

Signalhandler können beliebige BIOS, XBIOS und GEMDOS Aufrufe machen. AES- oder VDI-Aufrufe sind hingegen nicht gestattet. Dies gilt jedoch nicht in MagiC; hier gibt es einige Unterschiede zu beachten.

Ein Aufruf von Psigaction hat den Nebeneffekt, daß das Signal demaskiert (d.h. freigegeben) wird. So kann ein Prozess beim Abarbeiten eines Signals dieses zurücksetzen und es sich erneut zusenden, um sich beispielsweise selbst zu suspendieren, während ein Signal für Job-Control bearbeitet wird. Die Signalbearbeitung ist gegenüber Pfork/Pvfork abgesichert.

Signale, die von einem Prozess ignoriert werden, werden auch vom Child nach einem Pexec-Aufruf ignoriert. Außerdem werden Signale, die von einem Signal-Handler abgefangen werden, im Child-Prozess auf den Defaultwert zurückgesetzt.

Die Komponente sa_flags der sigaction-Struktur definiert ein zusätzliches, Signal-spezifisches Verhalten. Wenn sig das Signal SIGCHLD ist, und in sa_flags das SA_NOCLDSTOP Bit gesetzt ist, wird SIGCHLD dem Prozess nur dann gesendet, wenn einer seiner Childs terminiert (und eben nicht dann, wenn ein Child durch ein Job-Control-Signal suspendiert wird).
Ergebnis: Die Funktion kann folgende Rückgabewerte liefern:
E_OK  : kein Fehler aufgetreten.
EACCDN: Signal kann vom Benutzer nicht abgefangen werden.
ERANGE: sig ist kein gültiges Signal.

Verfügbar: Verfügbar, wenn ein 'MiNT' Cookie mit einer Versionsnummer von mindestens 0.95 existiert und in MagiC ab Version 4.50.
Gruppe: Prozessfunktionen
Querverweis: Binding   Pkill   Psigblock   Psignal   Psigreturn   Signale

5.11.32.1 Bindings für Psigaction

C: int32_t Psigaction ( int16_t sig, struct sigaction *act, struct sigaction *oact );
Assembler:
pea       oact         ; Offset 8
pea       act          ; Offset 4
move.w    sig,-(sp)    ; Offset 2
move.w    #311,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
lea       $C(sp),sp    ; Stack korrigieren

5.11.33 Psigblock

Name: »Psigblock« - Signalmaske verändern.
Gemdosnummer: 278
Deklaration: int32_t Psigblock ( int32_t mask );
Beschreibung: Die Funktion Psigblock blockiert den Empfang ausgewählter Signale. Sie fügt die in mask angegebenen Signale der Menge der aktuell blockierenden Signale hinzu. Dabei repräsentiert jedes Bit des Parameters mask ein Signal. Wenn Bit n in mask gesetzt ist, bedeutet dies, daß das Signal mit der Nummer n blockiert wird.

Zu beachten ist, daß manche Signale (z.B. SIGKILL) nicht blockiert werden können. Der Kernel wird diese Signale aus mask löschen, bevor die jeweilige Änderung der Signalmengen vorgenommen wird.

Ferner sei darauf hingewiesen, daß blockierte Signale auch über Pfork/Pvfork Aufrufe hinweg blockiert bleiben. Nach einem Pexec-Aufruf startet der Child stets mit einer leeren Menge zu blockierender Signale, unabhängig davon, welche Signale vom Parent blockiert wurden.

Achtung: Diese Funktion ist optional, daher darf ein Aufruf mit EINVFN beantwortet werden.
Ergebnis: Die Funktion liefert die Menge der blockierten Signale zurück, die vor dem Aufruf gültig waren. Über einen Aufruf von Psigsetmask kann so die alte Menge wieder hergestellt werden.
Verfügbar: Seit der ersten in MultiTOS integrierten MiNT Version 1.04 und sie steht in MagiC ab Version 4.50 zur Verfügung.
Gruppe: Prozessfunktionen
Querverweis: Binding   Psigsetmask   Signale

5.11.33.1 Bindings für Psigblock

C: int32_t Psigblock ( int32_t mask );
Assembler:
move.l    mask,-(sp)   ; Offset 2
move.w    #278,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #6,sp        ; Stack korrigieren

5.11.34 Psigintr

Name: »Psigintr« - assigns a signal to a particular exception vector.
Gemdosnummer: 318 (0x013e)
Deklaration: int32_t Psigintr ( int16_t vec, int16_t sig );
Beschreibung: This function assigns a signal to a particular exception vector. When the exception occurs, the kernel will send the signal to the process.

vec specifies the exception vector. This is the same value as specified for Setexc() call. sig specifies the signal number that is supposed to be delivered when an exception assigned to the vector vec occurs. When both sig and vec are zero, all handlers installed by your program are removed.

You should install a signal handler prior to making this call, otherwise your process will most probably get killed by the first occurrence of the interrupt assigned to vec vector.
Also notice that the function is not available on machines equipped with 68000 and 68010 processors.

This function has been totally rewritten as of MiNT version 1.15.1. However, the only change visible to programs is that the old value of vec is no longer returned (it had little use anyway). Also, since long stack frames are needed, a 68020 or newer processor is required.

The handler set up by Psigintr gets removed when your process terminates.
Ergebnis: Returns E_OK on success, or a negative GEMDOS error code otherwise:
EBADARG: A signal or vector number was specified outside the allowed range. Only autovectors ($60-$7c), traps ($80-$bc) and user defined interrupts 0100-$03fc) are allowed (other interrupts already generate fixed signals).
ENOMEM: The kernel ran out of memory while trying to allocate RAM for internal structures needed by this call.
ENXIO: The interrupt you want to register has no service routine installed.
ENOSYS: The function is not available (wrong architecture).

Verfügbar: When a 'MiNT' cookie with a version of at least 1.11 exists. As of MiNT version 1.15.1 this call is available only on machines equipped with 68020 processor or newer.
Gruppe: Prozessfunktionen
Querverweis: Binding   Pause   Pkill   Psigsetmask   Psignal   Signale

5.11.34.1 Bindings für Psigintr

C: int32_t Psigintr ( int16_t vec, int16_t sig );
Assembler:
move.w    sig,-(sp)    ; Offset 4
move.w    vec,-(sp)    ; Offset 2
move.w    #318,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #6,sp        ; Stack korrigieren

5.11.35 Psignal

Name: »Psignal« - Art der Signalbehandlung verändern.
Gemdosnummer: 274
Deklaration: int32_t Psignal ( int16_t sig, int32_t handler );
Beschreibung: Die Funktion ändert die Art und Weise, wie auf das Signal sig reagiert werden soll. Der Parameter handler kann 3 verschiedene Werte annehmen:
handler Bedeutung
   
0 Das Signal wird mit der Default-Aktion beantwortet.
1 Das Signal wird ignoriert. Liegt es gerade an, so wird es gelöscht.



Jeder andere Wert wird als die Adresse einer Benutzerfunktion interpretiert, die beim Auftreten des Signals sig aufgerufen wird. Dieser Funktion wird (über den Stack) ein Long-Wert übergeben, welcher der Signalnummer entspricht. Auf diese Art ist es möglich, den Signal-Handler für mehrere Signale zu benutzen.

Solange ein Signal bearbeitet wird, kann es nicht erneut gesendet werden. Zu beachten ist ferner, daß (im Gegensatz zu einigen Unix-Versionen) das Signal-Handling vor der Ausführung des Handlers nicht auf den Default-Handler zurückgesetzt wird.

Der Signalhandler muß entweder mit RTS (Return to Sender) beendet werden, oder Psigreturn aufrufen, um anzuzeigen, daß die Signalbehandlung abgeschlossen ist. Anschließend wird die Blockierung des Signals aufgehoben. Psigreturn führt zusätzlich einige interne Säuberungen des Kernels durch, die notwendig sind, falls der Signal-Handler nicht beendet wird (longjump).

Signalhandler können beliebige BIOS, XBIOS und GEMDOS Aufrufe machen. AES- oder VDI-Aufrufe sind hingegen nicht gestattet. Dies gilt jedoch nicht in MagiC; hier gibt es einige Unterschiede zu beachten.

Ein Aufruf von Psignal hat den Nebeneffekt, daß das Signal demaskiert (d.h. freigegeben) wird. So kann ein Prozess beim Abarbeiten eines Signals dieses zurücksetzen und es sich erneut zusenden, um sich beispielsweise selbst zu suspendieren, während ein Signal für Job-Control bearbeitet wird. Die Signalbearbeitung ist gegenüber Pfork/Pvfork abgesichert.

Signale, die von einem Prozess ignoriert werden, werden auch vom Child nach einem Pexec-Aufruf ignoriert. Außerdem werden Signale, die von einem Signal-Handler abgefangen werden, im Child-Prozess auf den Defaultwert zurückgesetzt.
Ergebnis: Die Funktion liefert den alten Wert des Signal-Handlers zurück. Dies ist entweder 0, 1 oder die Adresse des Handlers.

Im Fehlerfall werden folgende Werte zurückgeliefert:
EACCDN: das Signal kann nicht abgefangen werden.
ERANGE: sig ist kein gültiges Signal.

Verfügbar: Seit der ersten in MultiTOS integrierten MiNT Version 1.04 und in MagiC ab der Version 4.50.
Gruppe: Prozessfunktionen
Querverweis: Binding   Pkill   Psigaction   Psigblock   Psigreturn   Signale

5.11.35.1 Bindings für Psignal

C: int32_t Psignal ( int16_t sig, int32_t handler );
Assembler:
move.l    handler,-(sp)  ; Offset 4
move.w    sig,-(sp)      ; Offset 2
move.w    #274,-(sp)     ; Offset 0
trap      #1             ; GEMDOS aufrufen
addq.l    #8,sp          ; Stack korrigieren

5.11.36 Psigpause

Name: »Psigpause« - Prozess bis zum Eintreffen eines Signals suspendieren.
Gemdosnummer: 310
Deklaration: void Psigpause ( int32_t mask );
Beschreibung: Die Funktion setzt die neue Signalmaske mask, und suspendiert den aufrufenden Prozess, bis ein Signal eintrifft, welches nicht maskiert ist oder ignoriert wird.

Falls per Psignal für dieses Signal ein Handler installiert wurde, wird dieser aufgerufen, bevor die Funktion zurückkehrt. Falls der Handler einen longjump in einen anderen Programmteil ausführt oder der Prozess terminiert, wird die Funktion niemals zurückkehren.

Hinweis: Wenn die Funktion zurückkehrt, wird die Signalmaske auf den Wert zurückgesetzt, der vor dem Aufruf von Psigpause gültig war. Die von der Funktion gesetzte Signalmaske ist also nur temporär gültig. In MagiC kann es Probleme geben wenn mehrere Threads gleichzeitig diese Funktion aufrufen, da die Signalmaske hier prozessglobal ist.
Ergebnis: Die Funktion liefert immer 0 zurück.
Verfügbar: Verfügbar, wenn ein 'MiNT' Cookie mit einer Versionsnummer von mindestens 0.95 existiert und in MagiC ab Version 4.50.
Gruppe: Prozessfunktionen
Querverweis: Binding   Pause   Psigblock   Psignal   Psigsetmask   Signale

5.11.36.1 Bindings für Psigpause

C: void Psigpause ( int32_t mask );
Assembler:
move.w    mask,-(sp)   ; Offset 2
move.w    #310,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #4,sp        ; Stack korrigieren

5.11.37 Psigpending

Name: »Psigpending« - feststellen welche Signale abgeschickt, aber nicht bearbeitet wurden.
Gemdosnummer: 291
Deklaration: int32_t Psigpending ( void );
Beschreibung: Die Funktion liefert die Signale, die dem aufrufenden Prozess zwar gesendet, aber nicht bearbeitet wurden. (z.B. weil sie per Psigblock blockiert sind oder weil sie gerade in Bearbeitung sind).
Ergebnis: Die Funktion liefert die gewünschten Signale als Bitmaske in einem LONG zurück, für jedes gesetzte Bit n steht das Signal n zum Bearbeiten an.
Verfügbar: Seit der ersten in MultiTOS integrierten MiNT Version 1.04 und in MagiC ab der Version 4.50.
Gruppe: Prozessfunktionen
Querverweis: Binding   Psigblock   Psignal   Psigsetmask   Signale

5.11.37.1 Bindings für Psigpending

C: int32_t Psigpending ( void );
Assembler:
move.w    #291,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #2,sp        ; Stack korrigieren

5.11.38 Psigreturn

Name: »Psigreturn« - Verlassen eines Signal Handlers.
Gemdosnummer: 282
Deklaration: void Psigreturn ( void );
Beschreibung: Die Funktion bereitet das Verlassen eines Signal-Handlers vor. Da dies automatisch geschieht wenn der Handler zurückkehrt, ist ein Aufruf von Psigreturn nur notwendig, falls der Handler einen nicht-lokalen Sprung durchführt (etwa per longjump).

Der Aufruf hat keine Wirkung, wenn z.Zt. kein Signal bearbeitet wird.

In MagiC wird der Thread der aktiven Signalbehandlung zum Haupt-Thread des Prozesses und anschließend entfernt. Alle anderen Signalbehandlungen werden ebenfalls entfernt (Verschachtelung). Die gesperrten Semaphoren des Haupt-Thread werden freigegeben, der Supervisor-Stack wird auf den Wert bei Prozeßstart zurückgesetzt.
Ergebnis: Die Funktion besitzt unter MiNT/MultiTOS kein direktes Ergebnis; in MagiC wird der Wert EACCDN zurückgeliefert falls der Aufrufer keine Signalbehandlungsroutine ist, und anderenfalls der Wert E_OK.
Verfügbar: Seit der ersten in MultiTOS integrierten MiNT Version 1.04 und MagiC ab der Version 4.50.
Gruppe: Prozessfunktionen
Querverweis: Binding   Psignal   Signale   Signalhandler in MagiC

5.11.38.1 Bindings für Psigreturn

C: void Psigreturn ( void );
int32_t Psigreturn ( void );
Assembler:
move.w    #282,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #2,sp        ; Stack korrigieren

5.11.39 Psigsetmask

Name: »Psigsetmask« - Signalmaske ersetzen.
Gemdosnummer: 279
Deklaration: int32_t Psigsetmask ( int32_t mask );
Beschreibung: Die Funktion ersetzt die Menge der aktuell zu blockierenden Signale vollständig durch die im Parameter mask spezifizierten Signale.

Zu beachten ist, daß manche Signale (z.B. SIGKILL) nicht blockiert werden können. Der Kernel wird diese Signale aus mask löschen, bevor die jeweilige Änderung der Signalmengen vorgenommen wird.

Ferner sei darauf hingewiesen, daß blockierte Signale auch über Pfork/Pvfork Aufrufe hinweg blockiert bleiben. Nach einem Pexec-Aufruf startet der Child stets mit einer leeren Menge zu blockierender Signale, unabhängig davon, welche Signale vom Parent blockiert wurden.
Ergebnis: Die Funktion liefert die Menge der blockierten Signale zurück, die vor dem Aufruf gültig waren.
Verfügbar: Seit der ersten in MultiTOS integrierten MiNT Version 1.04 und in MagiC ab der Version 4.50.
Gruppe: Prozessfunktionen
Querverweis: Binding   Psigblock   Signale   Signalhandler in MagiC

5.11.39.1 Bindings für Psigsetmask

C: int32_t Psigsetmask ( int32_t mask );
Assembler:
move.l    mask,-(sp)   ; Offset 2
move.w    #279,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #6,sp        ; Stack korrigieren

5.11.40 Pterm

Name: »process termination« - beendet ein TOS-Programm.
Gemdosnummer: 76
Deklaration: void Pterm ( uint16_t retcode );
Beschreibung: Die GEMDOS-Routine Pterm beendet den laufenden Prozess, und entfernt diesen aus dem Speicher. Es gilt:
Parameter Bedeutung
   
retcode Status, der an das aufrufende Programm zurückgegeben wird.
-32 = sollte nicht benutzt werden, da man diesen Wert bei per Control-C abgebrochenen Programmen erhält.
 -1 = sollte nicht benutzt werden, da dieser Wert ab GEMDOS 0.15 bei einem Programmabsturz zurückgeliefert wird.
  0 = kein Fehler aufgetreten
  1 = allgemeiner Fehler
  2 = Fehler in den Parametern


Hinweis zu MagiC: Bevor irgendwelche Maßnahmen ergriffen werden, wird über Setexc der Vektor etv_term ermittelt und über diesen gesprungen. Anschließend wird der Prozeß ordentlich abgeräumt (einschließlich VDI-Workstations, Informierung aller XFSs über xfs_pterm, schließen aller geöffneten Dateien und aktuellen Pfade und Löschen der Prozeßdatei im Verzeichnis U:\PROC).
Ergebnis: Die Funktion liefert kein Ergebnis.
Verfügbar: Alle GEMDOS Versionen.
Gruppe: Prozessfunktionen
Querverweis: Binding   Pexec   Pterm0   Ptermres   XFS-Konzept in MagiC

5.11.40.1 Bindings für Pterm

C: void Pterm ( uint16_t retcode );
Assembler:
move.w    retcode,-(sp)  ; Offset 2
move.w    #76,-(sp)      ; Offset 0
trap      #1             ; GEMDOS aufrufen
addq.l    #4,sp          ; Stack korrigieren

5.11.41 Pterm0

Name: »process termination« - beendet ein TOS-Programm.
Gemdosnummer: 0
Deklaration: void Pterm0 ( void );
Beschreibung: Die GEMDOS-Routine Pterm0 beendet ein TOS-Programm und kehrt nicht wieder zurück. Die Routine liefert den Return-Code 0 zurück.

Hinweis: In MagiC wird diese Funktion direkt als Pterm(0) ausgeführt.
Ergebnis: Die Funktion liefert kein Ergebnis.
Verfügbar: Alle GEMDOS Versionen.
Gruppe: Prozessfunktionen
Querverweis: Binding   Pexec   Pterm   Ptermres

5.11.41.1 Bindings für Pterm0

C: void Pterm0 ( void );
Assembler:
move.w    #0,-(sp)     ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #2,sp        ; Stack korrigieren

5.11.42 Ptermres

Name: »terminate and stay resident« - Programm beenden, aber im Speicher behalten.
Gemdosnummer: 49
Deklaration: void Ptermres ( int32_t keepcnt, int16_t retcode );
Beschreibung: Die GEMDOS-Routine Ptermres beendet ein Programm, ein Teil der TPA des Programms verbleibt jedoch intakt und der verbliebene Speicher wird aus Speicherverwaltung des GEMDOS entfernt. Es gilt:
Parameter Bedeutung
   
keepcnt Anzahl der Bytes, die resident gehalten werden sollen (gilt ab Anfang der Basepage und schließt die Länge des TEXT, DATA und BSS Segments des Programms plus der Länge des Stacks ein; Minimum sind 128 Bytes).
Achtung: Der nach diesem Aufruf verbliebene Speicher kann später nicht freigegeben werden, da er komplett aus der Speicherverwaltung des GEMDOS entfernt wurde.
retcode Status, der an das aufrufende Programm zurückgegeben wird.
-32 = sollte nicht benutzt werden, da man diesen Wert bei per Control-C abgebrochenen Programmen erhält.
 -1 = sollte nicht benutzt werden, da dieser Wert ab GEMDOS 0.15 bei einem Programmabsturz zurückgeliefert wird.
  0 = kein Fehler aufgetreten
  1 = allgemeiner Fehler
  2 = Fehler in den Parametern


Hinweis: Im Netzwerk werden alle Lockings des Prozesses aufgehoben.
Ergebnis: Die Funktion liefert kein Ergebnis.
Verfügbar: Alle GEMDOS Versionen.
Gruppe: Prozessfunktionen
Querverweis: Binding   Pexec   Pterm   Pterm0

5.11.42.1 Bindings für Ptermres

C: void Ptermres ( int32_t keepcnt, int16_t retcode );
Assembler:
move.w    retcode,-(sp)  ; Offset 6
move.l    keepcnt,-(sp)  ; Offset 2
move.w    #49,-(sp)      ; Offset 0
trap      #1             ; GEMDOS aufrufen
addq.l    #8,sp          ; Stack korrigieren

5.11.43 Ptrace

Name: »Ptrace« - process tracing and debugging
Gemdosnummer: 265
Deklaration: int16_t Ptrace(int16_t request, int16_t pid, void * addr, int32_t data)
Beschreibung: Ptrace provides tracing and debugging facilities. It allows one pro- cess (the tracing process) to control another (the traced process). Most of the time, the traced process runs normally, but when it receives a signal (see sigaction(2)), it stops. The tracing process is expected to notice this via wait(2) or the delivery of a SIGCHLD signal, examine the state of the stopped process, and cause it to terminate or continue as appropriate. Ptrace is the mechanism by which all this happens.

The request argument specifies what operation is being performed; the meaning of the rest of the arguments depends on the operation, but except for one special case noted below, all ptrace calls are made by the tracing process, and the pid argument specifies the process ID of the traced process. request can be:
PT_TRACE_ME (0) This request is the only one used by the traced process; it declares that the process expects to be traced by its par- ent. All the other arguments are ignored. (If the parent process does not expect to trace the child, it will proba- bly be rather confused by the results; once the traced pro- cess stops, it cannot be made to continue except via ptrace.) When a process has used this request and calls execve(2) or any of the routines built on it (such as execv(3)), it will stop before executing the first instruc- tion of the new image. Also, any setuid or setgid bits on the executable being executed will be ignored.
PT_READ_I (1), PT_READ_D (2)
These requests read a single int of data from the traced process' address space. Traditionally, ptrace has al- lowed for machines with distinct address spaces for in- struction and data, which is why there are two requests: conceptually, PT_READ_I reads from the instruction space and PT_READ_D reads from the data space. In the current NetBSD implementation, these two requests are completely identical. The addr argument specifies the address (in the traced process' virtual address space) at which the read is to be done. This address does not have to meet any align- ment constraints. The value read is returned as the return value from ptrace.
PT_WRITE_I (4), PT_WRITE_D (5)
These requests parallel PT_READ_I and PT_READ_D, except that they write rather than read. The data argument sup- plies the value to be written.
PT_CONTINUE (7) The traced process continues execution. addr is an address specifying the place where execution is to be resumed (a new value for the program counter), or (caddr_t)1 to indi- cate that execution is to pick up where it left off. data provides a signal number to be delivered to the traced pro- cess as it resumes execution, or 0 if no signal is to be sent.
PT_KILL (8) The traced process terminates, as if PT_CONTINUE had been used with SIGKILL given as the signal to be delivered.
PT_ATTACH (9) This request allows a process to gain control of an other- wise unrelated process and begin tracing it. It does not need any cooperation from the to-be-traced process. In this case, pid specifies the process ID of the to-be-traced process, and the other two arguments are ignored. This re- quest requires that the target process must have the same real UID as the tracing process, and that it must not be executing a setuid or setgid executable. (If the tracing process is running as root, these restrictions do not ap- ply.) The tracing process will see the newly-traced pro- cess stop and may then control it as if it had been traced all along.

Two other restrictions apply to all tracing processes, even those running as root. First, no process may trace the process running init(8). Second, if a process has its root directory set with chroot(2), it may not trace another pro- cess unless that process's root directory is at or below the tracing process's root.
PT_DETACH (10) This request is like PT_CONTINUE, except that it does not allow specifying an alternative place to continue execu- tion, and after it succeeds, the traced process is no longer traced and continues execution normally.
PT_SYSCALL (11) Continue and stop at next return from syscall.



Additionally, machine-specific requests can exist. On the SPARC, these are:
PT_GETREGS This request reads the traced process' machine registers into the struct reg (defined in ) point- ed to by addr.
PT_SETREGS This request is the converse of PT_GETREGS; it loads the traced process' machine registers from the struct reg (defined in ) pointed to by addr.
PT_GETFPREGS This request reads the traced process' floating-point reg- isters into the struct fpreg (defined in ) pointed to by addr.
PT_SETFPREGS This request is the converse of PT_GETFPREGS; it loads the traced process' floating-point registers from the struct fpreg (defined in ) pointed to by addr.

Ergebnis: Some requests can cause ptrace to return -1 as a non-error value; to disambiguate, errno can be set to 0 before the call and checked after- wards. The possible errors are:
ww No process having the specified process ID exists.
EINVAL
  • A process attempted to use PT_ATTACH on itself.
  • The request was not one of the legal requests.
  • The signal number (in data) to PT_CONTINUE was neither 0 nor a legal signal number.
  • PT_GETREGS, PT_SETREGS, PT_GETFPREGS, or PT_SETFPREGS was at- tempted on a process with no valid register set. (This is nor- mally true only of system processes.)
EBUSY
  • PT_ATTACH was attempted on a process that was already being traced.
  • A request attempted to manipulate a process that was being traced by some process other than the one making the request.
  • A request (other than PT_ATTACH) specified a process that wasn't stopped.
EPERM
  • A request (other than PT_ATTACH) attempted to manipulate a pro- cess that wasn't being traced at all.
  • An attempt was made to use PT_ATTACH on a process in violation of the requirements listed under PT_ATTACH above.
Verfügbar: This function is available since FreeMiNT 1.15.11.
Gruppe: Prozessfunktionen
Querverweis: Binding

5.11.43.1 Bindings für Ptrace

C: int16_t Ptrace(int16_t request, int16_t pid, void * addr, int32_t data);
Assembler:
move.l    date         ; Offset 10
pea       addr         ; Offset 6
move.w    pid          ; Offset 4
move.w    request      ; Offset 2
move.w    #265,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #14,sp       ; Stack korrigieren

5.11.44 Pumask

Name: »Pumask« - Datei und Verzeichnis Erstellungsmaske setzen.
Gemdosnummer: 307
Deklaration: int16_t Pumask ( int16_t mode );
Beschreibung: Die Funktion ändert die Datei-/Verzeichnis Erstellungsmaske des aktuellen Prozesses auf mode, welches eine WORD Bitmaske mit den durch Fchmod definierten Zugriffsrechten ist. Der neue Wert der Maske wird an Child-Prozesse vererbt.

Wenn eine neue Datei (per Fcreate) oder ein neues Verzeichnis (per Dcreate) erzeugt wird, werden die Zugriffsrechte normalerweise so gesetzt, daß ein voller Zugriff erlaubt ist. (Ausnahme: neue Dateien sind normalerweise nicht ausführbar).

Mit Hilfe von Pumask kann festgelegt werden, welche Zugriffsrechte bei der Erzeugung einer Datei nicht (!) erlaubt sein sollen.

Explizite Fchmod-Aufrufe werden von Pumask nicht beeinflußt.

Achtung: In MagiC wird die Maske allerdings von keinem der internen XFS von MagiC ausgewertet und hat ihren Sinn ausschließlich bei UNIX-ähnlichen Dateisystemen.
Ergebnis: Die Funktion liefert den Wert der alten Erstellungsmaske.
Verfügbar: Verfügbar, wenn ein 'MiNT' Cookie mit einer Versionsnummer von mindestens 0.92 existiert und in MagiC ab Version 5.04.
Gruppe: Prozessfunktionen
Querverweis: Binding   Dcreate   Fchmod   Fcreate

5.11.44.1 Bindings für Pumask

C: int16_t Pumask ( int16_t mode );
Assembler:
move.w    mode,-(sp)   ; Offset 2
move.w    #307,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #4,sp        ; Stack korrigieren

5.11.45 Pusrval

Name: »Pusrval« - spezifische Informationen eines Prozesses setzen bzw. abfragen.
Gemdosnummer: 280
Deklaration: int32_t Pusrval ( int32_t val );
Beschreibung: Die Funktion erlaubt das Setzen bzw. Abfragen von Prozessspezifischen Informationen. Diese werden in einem Langwort gespeichert, und an alle Child-Prozesse weitervererbt.

Die Bedeutung des Wertes kann vom aufrufenden Programm frei bestimmt werden.
Ergebnis: Die Funktion liefert den alten Wert zurück.
Verfügbar: Seit der ersten in MultiTOS integrierten MiNT Version 1.04 und in MagiC ab der Version 5.04.
Gruppe: Prozessfunktionen
Querverweis: Binding

5.11.45.1 Bindings für Pusrval

C: int32_t Pusrval ( int32_t val );
Assembler:
move.l    val,-(sp)    ; Offset 2
move.w    #280,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #6,sp        ; Stack korrigieren

5.11.46 Pvfork

Name: »Pvfork« - Kopie des aktuellen Prozesses erstellen.
Gemdosnummer: 275
Deklaration: int16_t Pvfork ( void );
Beschreibung: Die Funktion erzeugt eine Kopie des aktuellen Prozesses. Parent- und Childprozess teilen sich denselben Adressraum, d.h. jede Änderung, die der Child an Variablen vornimmt, betreffen auch den Parent. Der neue Prozess beginnt seine Arbeit, wenn die Funktion Pvfork zurückkehrt.

Auch wenn der Parent diese Funktion aus dem Supervisormode aufruft, läuft das Child im Usermode.

Da sich beide Prozesse den gleichen Adressraum (und Stack) teilen, gäbe es Probleme, wenn beide zur gleichen Zeit laufen würden. Deshalb wird der Parent angehalten, bis der Child-Prozess entweder beendet wird oder sich mittels Pexec (Modus 200) selbst mit einem neuen Prozess in einem neuen Adressraum überschreibt.
Ergebnis: Die Funktion kann folgende Rückgabewerte liefern:
E_OK  : im Child-Prozess.
>0    : neue Prozess-ID im Parent-Prozess.
ENSMEM: nicht genug Speicher vorhanden, um den neuen Prozeß zu erzeugen.

Verfügbar: Seit der ersten in MultiTOS integrierten MiNT Version 1.04.
Gruppe: Prozessfunktionen
Querverweis: Binding   Pexec   Pfork   Threads

5.11.46.1 Bindings für Pvfork

C: int16_t Pvfork ( void );
Assembler:
move.w    #275,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #2,sp        ; Stack korrigieren

5.11.47 Pwait

Name: »Pwait« - auf Childprozess warten, Exitcode ermitteln.
Gemdosnummer: 265
Deklaration: int32_t Pwait ( void );
Beschreibung: Diese Funktion ist äquivalent zu Pwait3 (2, NULL) und wird aus Gründen der Abwärtskompatibilität angeboten.

Laut POSIX sollte die Bibliotheksfunktion 'wait' als Pwaitpid (-1, 0, NULL) implementiert werden. Daher sollte Pwait für eine POSIX-kompatible Bibliothek nicht benutzt werden.

Achtung: In MagiC ist die Funktion als Pwaitpid (-1, 2, NULL) implementiert.
Ergebnis: Die Funktion kann folgende Rückgabewerte liefern:
>0    : Exit-Status und PID des Childs in den unteren bzw. oberen 16 Bits eines 32-Bit Returnwerts.
 0    : Kein Child Prozess ist terminiert.
EFILNF: es existieren keine Childs.

Verfügbar: Seit der ersten in MultiTOS integrierten MiNT Version 1.04 und in MagiC ab Version 5.04.
Gruppe: Prozessfunktionen
Querverweis: Binding   Pwait3   Pwaitpid

5.11.47.1 Bindings für Pwait

C: int32_t Pwait ( void );
Assembler:
move.w    #265,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #2,sp        ; Stack korrigieren

5.11.48 Pwait3

Name: »Pwait3« - auf Childprozess warten, Exitcode ermitteln.
Gemdosnummer: 284
Deklaration: int32_t Pwait3 ( int16_t flag, int32_t *rusage );
Beschreibung: Diese Funktion ist äquivalent zu einem Aufruf von Pwaitpid (-1, flag, rusage) und ermittelt damit den Exit-Status sowie die CPU-Auslastung eines terminierten oder beendeten Child-Prozesses.

flag ist eine Bitmaske, die das Verhalten des Funktionsaufrufs wie folgt festlegt:
Wert Bedeutung
   
1 Wenn gesetzt, blockiert die Funktion nicht den aufrufenden Prozess und liefert 0 zurück. Wenn nicht gesetzt (gelöscht), wird der Prozess solange blockiert bis das Child sich beendet oder gestoppt wurde.
2 Wenn gesetzt, werden die Returnwerte von Prozessen die beendet wurden genauso wie von gestoppten zurückgeliefert. Wenn gelöscht, werden nur Returnwerte von Prozessen die aktuell beendet wurden, zurückgeliefert.



rusage zeigt auf ein Feld mit zwei LONGS, die mit Informationen über den Verbrauch von Resourcen des beendeten oder gestoppten Prozesses gefüllt werden. Der erste LONG enthält die Anzahl Millisekunden, die vom Child verbraucht wurden. Der zweite LONG enthält die Anzahl Millisekunden, die der Prozess im Kernelspace verbracht hat. Wird diese Information nicht gewünscht, kann rusage auf NULL gesetzt werden.
Ergebnis: Die Funktion kann folgende Rückgabewerte liefern:
>0    : Exit-Status und PID des Childs im unteren und oberen 16 bit des 32 Bit Returnwerts.
 0    : Kein Child Prozess wurde gestoppt oder beendet, oder, falls Bit-0 des Parameters flag gesetzt ist, die Funktion würde beim Warten auf das Exit bzw. Stop des Childs blockiert werden.
EFILNF: es existieren keine Childs.

Verfügbar: Seit der ersten in MultiTOS integrierten MiNT Version 1.04 und in MagiC ab Version 5.04.
Gruppe: Prozessfunktionen
Querverweis: Binding   Pwait   Pwaitpid

5.11.48.1 Bindings für Pwait3

C: int32_t Pwait3 ( int16_t flag, int32_t *rusage );
Assembler:
pea       rusage       ; Offset 4
move.w    flag,-(sp)   ; Offset 2
move.w    #284,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #8,sp        ; Stack korrigieren

5.11.49 Pwaitpid

Name: »Pwaitpid« - auf Childprozess warten, Exitcode ermitteln.
Gemdosnummer: 314
Deklaration: int32_t Pwaitpid ( int16_t pid, int16_t flag, int32_t *rusage );
Beschreibung: Die Funktion versucht den Exit-Code von Childprozessen, die gestoppt oder beendet worden sind, zu ermitteln. Falls Bit-1 des Parameters flag gesetzt ist, werden z.Zt. gestoppte, anderenfalls gerade beendete bzw. durch Tracing gestoppte Childprozesse gemeldet.

Ein gestoppter Prozess wird i.d.R. einmal gemeldet (sofern er nicht neu gestartet, und wieder gestoppt wurde). Ebenso wird ein beendetet Prozess nur einmal gemeldet.

Wenn Childs vorhanden sind, die weder gestoppt oder beendet sind (oder auf ein solches Ereignis warten), wird das weitere Verhalten der Funktion durch Bit-0 des Parameters flag gesteuert. Dabei gilt:
Bit-0 = 0: warten, bis Child stoppt oder beendet wird.
Bit-0 = 1: sofort zurückkehren.



Über den Parameter pid können die Childs genauer spezifiziert werden. Es gilt:
pid Bedeutung
   
-1 Status für alle Childs abfragen
>0 pid ist die Prozess-Kennung des Childs, dessen Status erfragt werden soll
=0 Status für alle Childs abfragen, deren Gruppen-ID gleich der des aufrufenden Prozesses ist.
< -1 Status für alle Childs abfragen, deren Gruppen-ID dem Absolutwert (Betrag) von pid entspricht.



Über den Parameter rusage werden Informationen über den Verbrauch an CPU-Zeit des Childs abgelegt:
rusage[0]: Zeitverbrauch im User-Space (msec)
rusage[1]: Zeitverbrauch im Kernel-Space (msec)



Falls ein Child gefunden wurde, wird dessen PID in den oberen 16-Bit und sein Exit-Status in den unteren 16-Bit des Rückgabewertes abgelegt. Wenn der Prozess durch das Signal mit der Nummer n gestoppt oder beendet wurde, ist sein Exit-Status 256*n+x mit:
x = 127, falls der Prozess gestoppt wurde.
x = 0, falls der Prozess beendet wurde.



Achtung: In MagiC werden angehaltene Child-Prozesse noch nicht erkannt, sondern nur beendete Childs. Darüber hinaus werden im Parameter rusage z.Zt. immer nur Null-Werte zurückgegeben.

Auch Prozeßgruppen werden z.Zt. noch nicht richtig unterstützt, da die Funktion Psetpgrp() noch fehlt.
Ergebnis: Die Funktion kann folgende Rückgabewerte liefern:
>0    : Exit-Status und PID des Childs im unteren und oberen 16 bit des 32 Bit Returnwerts.
 0    : Kein Child Prozess wurde gestoppt oder beendet, oder, falls Bit-0 des Parameters flag gesetzt ist, und die Funktion beim Warten auf das Exit bzw. Stop des Childs blockiert werden würde.
EFILNF: es existieren keine Childs.

Verfügbar: Verfügbar, wenn ein 'MiNT' Cookie mit einer Versionsnummer von mindestens 0.96 existiert und in MagiC ab Version 5.04.
Gruppe: Prozessfunktionen
Querverweis: Binding   Pwait   Pwait3

5.11.49.1 Bindings für Pwaitpid

C: int32_t Pwaitpid ( int16_t pid, int16_t flag, int32_t *rusage );
Assembler:
pea       rusage       ; Offset 6
move.w    flag,-(sp)   ; Offset 4
move.w    pid,-(sp)    ; Offset 2
move.w    #314,-(sp)   ; Offset 0
trap      #1           ; GEMDOS aufrufen
lea       $A(sp),sp    ; Stack korrigieren


HomeGEMDOSDatum und UhrzeitSpeicherverwaltung