Provided by: manpages-nl_20051127-4_all
 

NAAM

        ptrace - proces volgen
 

OVERZICHT

        #include <sys/ptrace.h>
 
        long  int ptrace(enum __ptrace_request verzoek, pid_t pid, void * addr,
        void * gegevens)
 

BESCHRIJVING

        De ptrace systeem aanroep levert een manier waardoor  een  ouder-proces
        de  uitvoering  van  een  ander  proces kan volgen en manipuleren: zijn
        geheugen-beeld en registers kan bekijken en veranderen. Het wordt in de
        eerste  plaats gebruikt om breekpunt-debuggen en systeem-aanroep-volgen
        te implementeren.
 
        De ouder kan het volgen beginnen door fork(2)  aan  te  roepen  en  het
        opgeleverde kind een PTRACE_TRACEME {volgme}, gevolgd (gewoonlijk) door
        een exec(2) te laten doen.  De ouder kan ook met volgen beginnen op een
        bestaand proces met PTRACE_ATTACH.
 
        Als  het  kind  gevolgd  wordt,  zal  het  elke  keer  dat  een signaal
        afgeleverd wordt stoppen, zelfs als het signaal  genegeerd  wordt.  (De
        uitzondering is SIGKILL {*vermoord}, die het gewoonlijke gevolg heeft.)
        De ouder wordt opmerkzaam gemaakt bij zijn volgende wait(2) en kan  het
        gestopte  kind-proces inspecteren en veranderen. De ouder zorgt dan dat
        het kind doorgaat, met eventueel het afgeleverde signaal genegeerd  (of
        zelfs een ander signaal afgevend in plaats daarvan).
 
        Als  de  ouder  klaar  is  met  volgen  kan het het kind beëindigen met
        PTRACE_KILL of zorgen dat het doorgaat met  uitvoeren  in  een  normale
        ongevolgde toestand met PTRACE_DETACH.
 
        De waarde van verzoek bepaald wat het doet:
 
        PTRACE_TRACEME
               {*volg  me} betekend dat het proces gevolgd zal gaan worden door
               zijn ouder. Elk signaal (behalve SIGKILL)  dat  aan  het  proces
               gegeven wordt maakt dat het stopt en dat zijn ouder geïnformeerd
               wordt via wait.  Ook zullen alle  volgende  aanroepen  van  exec
               door  dit  proces,  het  zenden  van een SIGTRAP naar het proces
               veroorzaken, ervoor zorgend dat de ouder een kans  heeft  om  de
               macht  over  te  nemen voordat een nieuw programma met uitvoeren
               begint. Een proces moet dit verzoek waarschijnlijk niet doen als
               zijn  ouder  niet  verwacht  om  het  te  volgen. (pid, addr, en
               gegevens worden genegeerd.)
 
        Het bovenstaande verzoek wordt alleen door het kind proces gebruikt; de
        rest  wordt  alleen  door  de  ouder gebruikt. In de volgende verzoeken
        bepaald pid het kind proces waarop gewerkt wordt. Voor andere verzoeken
        dan PTRACE_KILL moet het kind proces gestopt worden.
 
        PTRACE_PEEKTEXT, PTRACE_PEEKDATA
               {*gluur tekst} {*gluur gegevens} Leest een woord op positie addr
               in het geheugen van het kind, en geeft het terug als het  resul‐
               taat  van de ptrace aanroep. Linux heeft geen afzonderlijke text
               {code} en gegevens adres ruimtes, dus  de  twee  verzoeken  zijn
               momenteel gelijk. (gegevens wordt genegeerd.)
 
        PTRACE_PEEKUSER
               {*gluur  gebruiker}  Leest  een  woord  op  positie  addr in het
               GEBRUIKER gebied van het  kind,  waar  de  registers  en  andere
               informatie    over   het   proces   vastgehouden   worden   (zie
               <linux/user.h> en <sys/user.h>). Het  woord  wordt  teruggegeven
               als  het resultaat van een ptrace aanroep. Meestal moet de posi‐
               tie woord-opgelijnd zijn, hoewel dat per architectuur kan wisse‐
               len. (gegevens wordt genegeerd.)
 
        PTRACE_POKETEXT, PTRACE_POKEDATA
               {*prik  text}  {*prik  gegevens}  Kopieert  een woord op positie
               gegevens in het geheugen van de ouder, naar positie addr in  het
               geheugen  van het kind. Net als hierboven zijn de twee verzoeken
               momenteel gelijk.
 
        PTRACE_POKEUSER
               {*prik gebruiker} Kopieert een woord op positie gegevens in  het
               geheugen  van  de  ouder,  naar de positie addr in het kind zijn
               GEBRUIKER gebied. Net als boven moet de positie  meestal  woord-
               opgelijnd  zijn.  Om  de zuiverheid van de "kernel" te handhaven
               worden sommige  veranderingen  aan  het  GEBRUIKER  gebied  niet
               toegestaan.
 
        PTRACE_GETREGS, PTRACE_GETFPREGS
               Kopiëren  respectievelijk de algemeen gebruik-, of de drijvende-
               komma- registers van het kind naar positie gegevens in de ouder.
               Zie  <linux/user.h>  voor  informatie  over  de  vorm  van  deze
               gegevens. (addr wordt genegeerd.)
 
        PTRACE_SETREGS, PTRACE_SETFPREGS
               {*zet registers} {*zet  Fregisters}  Zetten  respectievelijk  de
               algemeen  gebruik-,  of  de  drijvende-komma-  registers van het
               kind,  van  positie  gegevens  in  de  ouder.   Net   als   voor
               PTRACE_POKEUSER  kunnen  sommige  veranderingen  in de algemeen-
               gebruik-registers niet worden toegestaan.
 
        PTRACE_CONT
               {*ga-door}  Herstart  het  gestopte  kind-proces.  Als  gegevens
               ongelijk-nul  is  en niet SIGSTOP, dan wordt het geïnterpreteerd
               als een signaal dat afgeleverd wordt aan het kind; anders  wordt
               geen  signaal  afgeleverd. Dus de ouder kan bijvoorbeeld bepalen
               of een signaal dat naar het kind werd gezonden aangeboden  wordt
               of niet. (addr wordt genegeerd.)
 
        PTRACE_SYSCALL, PTRACE_SINGLESTEP
               {*systeemaanr.}  {*enkele  stap}  Herstart het gestopte kind net
               als PTRACE_CONT, maar zorgt ervoor dat het  kind  gestopt  wordt
               bij  de  volgende  ingang naar- of uitgang van- een systeem aan‐
               roep, of  na  uitvoering  van  een  enkele  instructie,  respec‐
               tievelijk.   (Het  kind  zal  ook  -zoals  gebruikelijk-  worden
               gestopt bij ontvangst van een signaal.) Gezien vanuit  de  ouder
               zal het lijken of het kind gestopt is bij ontvangst van een SIG‐
               TRAP. Dus voor PTRACE_SYSCALL bijvoorbeeld is het  idee  om:  de
               argumenten  naar een systeemaanroep te onderzoeken bij de eerste
               stop, dan nog een PTRACE_SYSCALL te doen, en de teruggeef-waarde
               van  de systeem aanroep te onderzoeken bij de tweede stop. (addr
               wordt genegeerd.)
 
        PTRACE_KILL
               {*vermoord} Zend het kind een  SIGKILL  om  het  te  beëindigen.
               (addr en gegevens worden genegeerd.)
 
        PTRACE_ATTACH
               {*mount}  mount  aan een proces bepaald in pid, en maakt het een
               gevolgd "kind" van het huidige proces; het gedrag van  het  kind
               is  alsof  het een PTRACE_TRACEME had gedaan. Het huidige proces
               wordt feitelijk de ouder van  het  kind  voor  de  meeste  zaken
               (o.a.,  zal het kennis nemen van kind-gebeurtenissen en in ps(1)
               uitkomst zal als de ouder verschijnen), maar een getpid(2)  door
               het  kind zal nog steeds de originele ouder teruggeven. Het kind
               wordt een SIGSTOP gezonden maar zal niet  noodzakelijkerwijs  al
               gestopt  zijn bij afronding van deze aanroep; gebruik wait om te
               wachten tot het kind stopt. (addr en gegevens worden genegeerd.)
 
        PTRACE_DETACH
               {*ontkoppel} Herstart een gestopt kind net als PTRACE_CONT, maar
               ontkoppeld eerst van  het  proces:  het  om-ouderen  gevolg  van
               PTRACE_ATTACH,  en  de gevolgen van PTRACE_TRACEME ongedaan mak‐
               end. Alhoewel  misschien  niet  bedoeld,  onder  Linux  kan  een
               gevolgd  kind  ontkoppeld  worden  via  deze weg, op welke welke
               manier het volgen ook begonnen was.
 

OPMERKINGEN

        Hoewel argumenten van ptrace worden geïnterpreteerd volgens het gegeven
        prototype, verklaard GNU libC ptrace momenteel als een variërende func‐
        tie met alleen het verzoek argument vereist. Dit betekend dat onnodige,
        achteraan  hangende  argumenten,  weggelaten  mogen  worden, hoewel dat
        gebruik maakt van onbeschreven gcc(1) gedrag.
 
        init(8), het proces met pid 1 mag niet gevolgd worden.
 
        De vorm van de inhoud van het geheugen en  het  GEBRUIKER  gebied  zijn
        nogal besturingssysteem- en architectuur- eigen.
 
        De maat voor een "word" {woord} wordt bepaald door de besturingssysteem
        soort (voor 32-bit Linux is het 32 bits, enz.).
 
        Volgen veroorzaakt een paar  kleine  verschillen  in  werking  van  het
        gevolgde  proces.  Bijvoorbeeld:  als  aan  een  proces  mount werd met
        PTRACE_ATTACH dan kan zijn originele ouder niet langer bericht via wait
        krijgen wanneer het stopt, en er is geen manier voor de nieuwe ouder om
        dit bericht na te bootsen.
 
        Deze pagina beschrijft de manier ptrace momenteel werkt in Linux.  Zijn
        gedrag  verschilt  nogal  van andere smaken Unix. In elk geval, gebruik
        van ptrace is zeer besturingssysteem- en architectuur- eigen.
 
        De SunOS handleiding beschrijft ptrace als "uniek en ouderwets", wat zo
        is. De proc-gebaseerde debuggings interfaces, aanwezig in in Solaris 2,
        implementeren meer dan de ptrace mogelijkheden op een sterkere en  meer
        eenvormige manier.
        Bij  success  geven PTRACE_PEEK* verzoeken de gevraagde gegevens terug,
        andere verzoeken geven nul terug. Bij falen geven alle verzoeken -1  en
        wordt  errno(3)  naar  behoren gezet. Omdat de waarde teruggegeven door
        een geslaagd PTRACE_PEEK* verzoek -1 kan zijn, moet de aanroeper  errno
        testen  na  dergelijke  verzoeken  om te bepalen of al of niet een fout
        optrad.
 

FOUTEN

        EPERM  {toestemming} Het bepaalde proces kan niet gevolgd  worden.  Dit
               kan  zijn  omdat  de  ouder onvoldoende rechten heeft; niet-root
               processen kunnen processen niet volgen  waar  ze  geen  signalen
               naar  kunnen  zenden,  of  processen  die setuid/setgid zijn, om
               overduidelijke redenen. Het proces zou  ook  al  gevolgd  kunnen
               worden, of init (pid 1) zijn.
 
        ESRCH  {zoek}  Het  bepaalde  proces bestaat niet, wordt momenteel niet
               gevolgd door de aanroeper, of is niet  gestopt  (voor  verzoeken
               die dat nodig hebben).
 
        EIO    {in/uit}  verzoek  is  ongeldig, of een poging werd gedaan om te
               lezen of schrijven van/naar een ongeldig gebied in het  geheugen
               van  de  ouder  of  het  kind,  of  er  was  een woord-oplijning
               schending, of een ongeldig signaal werd gegeven in een  herstart
               verzoek.
 
        EFAULT {fout}  Er  werd  een  poging  gedaan  om  te lezen of schrijven
               van/naar een ongeldig gebied in het geheugen van de ouder of het
               kind,  waarschijnlijk  omdat  het  gebied  niet voorhanden {eng:
               mapped} of toegankelijk was. Helaas geven onder Linux  verschil‐
               lende soorten van deze fout nogal lukraak EIO of EFAULT terug.
        SVr4, SVID EXT, AT&T, X/OPEN, BSD 4.3
 

ZIE

        exec(3)  {uitvoeren},  wait(2)  {wacht},  signal(2)  {signaal}, fork(2)
        {splits}, gdb(1) {gnu debugger}, strace(1) {volg}
 

VERTALING

        Dit is  een  handleiding  uit  manpages-dev  1.29.   Alles  wat  tussen
        ‘{’..‘}’ staat is aanvullende vertaling, en hoort niet bij de originele
        handleiding.  Email naar <manpages-nl@nl.linux.org>.
 
        $Id: ptrace.2,v 1.1.1.1 2004/03/21 21:02:25 cor Exp $