Linux commando: pwd

Elke shell-sessie zet je ergens neer in het bestandssysteem, en bijna elk commando dat je uitvoert hangt af van waar dat "ergens" is. pwd is het commando dat de eenvoudigste vraag in Linux beantwoordt: waar ben ik nu? Het lijkt het saaiste hulpmiddel op het systeem, en toch schuilt achter die drie letters een kleine verrassing over hoe de kernel je positie echt bijhoudt, en waarom twee versies van pwd het oneens kunnen zijn over precies dezelfde map.

2. Waar komt de naam vandaan?

De naam pwd is een afkorting van print working directory.

pwd  =  Print Working Directory

Zoals de meeste vroege Unix-commando's werd hij met opzet kort gemaakt. Vroege Unix werd getypt op trage teletype-terminals die elk teken op papier afdrukten, dus korte namen bespaarden zowel tijd als inkt. Daarom zijn zo veel kerncommando's twee of drie letters: ls (list), cp (copy), mv (move), cd (change directory) en pwd (print working directory).

Het woord "print" betekent hier "naar het scherm printen", wat in het teletype-tijdperk letterlijk op papier afdrukken betekende. Vandaag schrijft het gewoon een regel naar je terminal, maar de naam is nooit veranderd.

4. Eenvoudige toepassingen

4.1 Het eenvoudigst mogelijke gebruik

Typ pwd met niets erachter. Het toont een regel: het volledige, absolute pad van waar je bent. In het voorbeeld hieronder is de regel die begint met $ wat je typt, en de regel eronder is wat het systeem teruggeeft.

$ pwd
/home/peter/projects/website

Het pad begint altijd vanaf de wortel / en is absoluut, dus het is nooit dubbelzinnig. Waar je die regel ook plakt, hij betekent dezelfde map.

4.2 Het eerste dat je typt op een vreemde server

Wanneer je op een onbekende machine inlogt via SSH, of wanneer een script je op een onverwachte plek heeft achtergelaten, is pwd de veilige eerste stap. Het leest alleen; het verandert niets. Samen met ls en whoami beantwoordt het de drie vragen die je meteen orienteren.

$ whoami
peter
$ pwd
/var/www/example.com
$ ls
config  logs  public_html

Samen zeggen ze: ik ben de gebruiker peter, ik sta in de webroot van de site, en dit is wat erin zit. Nu weet je dat het veilig is om iets te doen.

4.3 De variabele $PWD

De shell bewaart je huidige map ook in een variabele die $PWD heet. Meestal tonen echo "$PWD" en pwd hetzelfde.

$ echo "$PWD"
/home/peter/projects/website

De shell houdt ook een bijbehorende variabele bij: $OLDPWD bevat de map waar je in zat voor de laatste cd. Het is de waarde die cd - aandrijft, de "spring terug"-snelkoppeling.

$ cd /etc
$ cd /var
$ echo "$OLDPWD"
/etc

Het verschil is dat $PWD een tekst is die de shell opslaat en vertrouwt, terwijl je pwd kunt vragen om het echte bestandssysteem te controleren. Dat gat is klein, maar het is precies waar de verrassingen in sectie 7 vandaan komen.

4.4 pwd in je prompt

Je typt pwd minder vaak dan je zou verwachten, omdat de meeste shells al een verkorte vorm van de huidige map in de prompt zelf tonen. In Bash zet de speciale code \w de werkmap in je promptreeks $PS1.

$ PS1='\u@\h:\w\$ '
peter@server:~/projects/website$

Hier is \w de werkmap (met je home getoond als ~), \u de gebruiker en \h de hostnaam. Wanneer je prompt al toont waar je bent, wordt pwd het hulpmiddel waar je in scripts naar grijpt en wanneer de prompt verborgen is.

6. Geavanceerde toepassingen

6.1 De builtin en het programma zijn het oneens

Hier is het feit waar zelfs ervaren gebruikers over struikelen. Er zijn twee pwd-commando's, en hun standaardgedrag is tegenovergesteld. Controleer het zelf:

$ type pwd
pwd is a shell builtin
$ which pwd
/bin/pwd

Wanneer je pwd typt, krijg je de shell-builtin, waarvan de standaard logisch (-L) is. Het aparte programma op /bin/pwd, van GNU coreutils, staat standaard op fysiek (-P). Ga in een map achter een symlink staan en de twee tonen verschillende paden voor dezelfde plek:

$ cd /home/peter/site          # a symlink to /var/www/html
$ pwd                          # the builtin: logical by default
/home/peter/site
$ /bin/pwd                     # the program: physical by default
/var/www/html

Geen van beide is fout; ze beantwoorden verschillende vragen. Maar als een script /bin/pwd aanroept en dezelfde uitvoer verwacht als een interactieve pwd, kan het verschil echte, lastig te vinden bugs veroorzaken. Wanneer het ertoe doet, wees expliciet en geef altijd zelf -L of -P mee in plaats van op de standaard te vertrouwen.

6.2 Hoe pwd het pad uberhaupt vindt

Herinner je het mentale model uit sectie 1: de kernel bewaart je positie als een verwijzing naar een map, niet als een tekst. Hoe zet een fysieke pwd die verwijzing dan terug om naar tekst zoals /var/www/html?

De klassieke methode is omhoog door de boom lopen. Elke map bevat een vermelding .. die naar zijn ouder wijst. Vanaf waar je bent kijkt pwd naar de ouder, vindt de naam die terugleidt naar de huidige map, onthoudt die, en herhaalt dit een niveau hoger, helemaal tot de wortel /. Die lijst met namen omgekeerd geeft het volledige pad.

current dir  --  ..  -->  parent    (find my name here: "html")
parent       --  ..  -->  /var/www  (find its name: "www")
/var/www     --  ..  -->  /var      (find its name: "var")
/var         --  ..  -->  /         (reached the root)

read the names in reverse:  / + var + www + html  =  /var/www/html

Modern Linux maakt dit snel met een enkele system call, getcwd(), dus de shell loopt de boom nauwelijks nog met de hand af. Maar het oude idee verklaart nog steeds het gedrag, vooral de fout die je in de volgende sectie zult zien. De logische builtin slaat dit allemaal over: hij toont gewoon de tekst die hij in $PWD heeft bewaard, en daarom is hij direct en kan hij soms verouderd zijn.

Diezelfde getcwd()-aanroep is wat elke programmeertaal onder de motorkap gebruikt. Daarom ziet "print de werkmap" er bijna identiek uit, welk hulpmiddel je ook gebruikt:

char *getcwd(char *buf, size_t size);   // C, the underlying call
os.getcwd()                             # Python
getcwd();                               // PHP

Het commando pwd is eigenlijk maar een dunne schil rond deze ene kerneldienst.

6.3 $PWD en de werkelijkheid gelijk houden

Omdat het logische antwoord uit een opgeslagen tekst komt, klopt het alleen zolang de shell die tekst up-to-date houdt. De shell doet dit voor je elke keer dat je cd gebruikt. Problemen ontstaan wanneer iets de map onder je verplaatst zonder dat de shell het weet, en dat is precies het geval in de volgende sectie.

8. Best practices

• Voer pwd uit zodra je je verloren voelt. Op een vreemde server, of wanneer een commando zich raar gedraagt, bevestig waar je bent voordat je iets doet. Het is alleen-lezen en kan niets kapotmaken.
• Wees expliciet over -L en -P wanneer het ertoe doet. Vertrouw in scripts niet op de standaard. Als je de echte locatie nodig hebt, schrijf pwd -P; als je het pad zoals genavigeerd nodig hebt, schrijf pwd -L.
• Onthoud dat pwd en /bin/pwd verschillend standaardgedrag hebben. De builtin is logisch, het coreutils-programma is fysiek. Een script dat ze mengt, kan twee paden vergelijken die nooit bedoeld waren om overeen te komen.
• Vang het pad op met "$(pwd)", altijd tussen aanhalingstekens. Aanhalingstekens beschermen paden met spaties, die op echte systemen vaak voorkomen.
• Als pwd verouderd lijkt, doe gewoon opnieuw cd. Nadat een map onder je is verplaatst of verwijderd, zet een verse cd naar een echt pad $PWD weer goed.
• Grijp naar de documentatie. Omdat er twee versies zijn, documenteren ze op twee plaatsen.

$ help pwd            # the built-in version (Bash)
$ man pwd             # the coreutils program at /bin/pwd
$ pwd --help          # a quick option summary from the program

Let op dat help pwd de builtin beschrijft die je shell echt uitvoert, terwijl man pwd /bin/pwd beschrijft. Wanneer hun gedrag verschilt, lees dan degene die past bij het commando dat je aanroept.

10. Samenvatting

Het commando pwd lijkt triviaal, maar het is een helder venster op hoe Linux je plek in het bestandssysteem bijhoudt.

• pwd betekent "print working directory". Het toont het absolute pad van de map waar je shell in staat.
• De huidige map is per proces en wordt door de kernel opgeslagen als een verwijzing naar een map, niet als een stukje tekst. pwd zet die verwijzing terug om naar een leesbaar pad.
• -L (logisch, de standaard builtin) toont het pad zoals je navigeerde, symlinks behouden. -P (fysiek) lost symlinks op naar de echte locatie.
• Er zijn twee versies: de shell-builtin (standaard logisch) en /bin/pwd van coreutils (standaard fysiek). Hun standaardgedrag is tegenovergesteld.
• Het logische antwoord komt uit de $PWD-tekst, dus het kan verouderd zijn; het fysieke antwoord wordt opnieuw opgebouwd uit het bestandssysteem en faalt als de map is verwijderd.
• Als een map onder je wordt verplaatst of verwijderd, kan pwd een oude naam tonen. Een verse cd lost het op.
• Documentatie staat op twee plaatsen: help pwd voor de builtin, man pwd voor het programma.

Dit is het overzicht dat het bewaren waard is:

pwd          print the current directory (logical, as navigated)
pwd -L       force the logical path (keep symlinks)
pwd -P       force the physical path (resolve symlinks)
/bin/pwd     the coreutils program (physical by default)
echo "$PWD"  the shell's stored copy of the path
here=$(pwd)  capture the path into a variable
help pwd     built-in manual (Bash)
man pwd      manual for /bin/pwd

Kleine commando's als pwd verbergen een verrassende hoeveelheid van hoe Linux is gebouwd, van toestand per proces tot het verschil tussen een naam en een echte locatie op schijf. Als je servers zich gedragen op manieren die moeilijk te verklaren zijn, of je wilt een opzet die dag in dag uit makkelijker te beheren is, loont het vaak om goed naar deze fundamenten te kijken. Dat is precies het soort werk waar ik graag bij help.