Linux commando: cd

Elke keer dat je je door een Linux-systeem beweegt, gebruik je cd. Je typt het om een project binnen te stappen, om er weer uit te klimmen en om over een server te springen voordat je een configuratiebestand bewerkt of een log leest. Het voelt als het eenvoudigste commando dat er is: kies een map, ga erheen. Toch is cd niet eens een echt programma, en begrijpen waarom leert je iets fundamenteels over hoe Unix werkt.

2. Waar komt de naam vandaan?

De naam cd is een afkorting van change directory (map wijzigen).

cd  =  Change Directory

Zoals de meeste vroege Unix-commando's is hij bewust kort gehouden. In de beginjaren van Unix werd getypt op trage teletype-terminals die elk teken letter voor letter op papier afdrukten, dus korte namen bespaarden zowel tijd als papier. Daarom bestaan zoveel basiscommando's uit twee letters: ls (list), cp (copy), mv (move), rm (remove) en cd (change directory).

Zodra een naam in het spiergeheugen van iedereen zit, is er geen reden om hem te veranderen. Vijftig jaar later is cd nog steeds cd op elk Unix-achtig systeem ter wereld.

4. Eenvoudige toepassingen

4.1 De eenvoudigst mogelijke verplaatsing

Geef cd een pad en het brengt je erheen. In de voorbeelden hieronder is de regel die begint met $ wat je typt; pwd ("print working directory") bevestigt waar je bent geland.

$ cd /var/log
$ pwd
/var/log

Merk op dat cd niets afdrukt wanneer het lukt. Stilte betekent succes. Dit is de Unix-gewoonte van "geen nieuws is goed nieuws": een commando laat pas van zich horen als er iets misgaat.

4.2 Absolute en relatieve paden

Je kunt cd op twee manieren naar een map wijzen. Een absoluut pad begint met een schuine streep en beschrijft de locatie vanaf de wortel van het bestandssysteem. Een relatief pad begint niet met een schuine streep en wordt begrepen vanaf waar je nu bent.

$ cd /etc/nginx        # absoluut: altijd dezelfde plek
$ cd sites-enabled     # relatief: een map binnen waar ik al ben

Relatieve paden maken cd snel. Als je al in /etc/nginx bent, typ je cd sites-enabled in plaats van het volledige pad.

4.3 Omhoog gaan: ..

Elke map bevat twee bijzondere items: . betekent "deze map" en .. betekent "de bovenliggende map". Je gebruikt .. voortdurend om weer omhoog te klimmen.

$ cd ..            # een niveau omhoog
$ cd ../..         # twee niveaus omhoog
$ cd ../sibling    # een omhoog, dan omlaag naar een buurmap

4.4 Naar huis gaan: cd zonder pad

Typ cd op zichzelf, zonder iets erachter, en het brengt je naar je home-map. Dit is de waarde van de variabele $HOME, meestal /home/jouwnaam.

$ cd
$ pwd
/home/peter

De tilde ~ is een afkorting voor diezelfde plek, en werkt ook als onderdeel van een langer pad:

$ cd ~             # home, hetzelfde als cd zonder pad
$ cd ~/Documents   # de map Documents binnen home
$ cd ~peter        # de home-map van gebruiker "peter"

4.5 Terugspringen: cd -

Dit is degene die als magie voelt zodra je hem kent. cd - brengt je terug naar de map waar je net daarvoor was, voor de laatste cd. Het wisselt tussen twee plekken, als de "vorige zender"-knop op een afstandsbediening.

$ pwd
/home/peter/project
$ cd /etc/nginx
$ cd -             # spring terug
/home/peter/project
$ cd -             # en weer terug
/etc/nginx

Merk op dat cd - ook de map afdrukt waar het naartoe ging. Het is de enige vorm van cd die niet stil is, omdat het handig is om te zien waar je bent geland. Achter de schermen onthoudt de shell je vorige map in een variabele genaamd $OLDPWD, en cd - springt daar simpelweg naartoe.

6. Geavanceerde toepassingen

6.1 Waarom cd een shell-builtin moet zijn

Hier komt het feit dat cd echt interessant maakt. Voer deze twee commando's uit:

$ type cd
cd is a shell builtin
$ which cd
$                       # geeft niets: er is geen programma dat cd heet

Er is geen bestand /bin/cd of /usr/bin/cd om uit te voeren. cd is ingebouwd in de shell. De reden is een van de belangrijkste regels in Unix: een kindproces kan de huidige map van zijn ouder niet wijzigen.

Wanneer je een gewoon programma als ls draait, start de shell het als een apart kindproces. Dat kind krijgt zijn eigen kopie van de huidige map. Als cd een gewoon programma was, zou het als kind starten, zijn eigen huidige map wijzigen en dan stoppen, en zou je shell (de ouder) geen millimeter zijn verplaatst. De wijziging zou met het kind verdwijnen.

shell (jouw proces)           huidige map: /home/peter
   |
   +-- start een programma      krijgt een KOPIE van de huidige map
        wijzigt zijn eigen map
        stopt                    de kopie wordt weggegooid
   |
shell (jouw proces)           huidige map: NOG STEEDS /home/peter

De enige manier om de eigen map van de shell te wijzigen is de code binnen het shell-proces uit te voeren, niet in een kind. Dat is precies wat een builtin is: een commando dat de shell zelf uitvoert. Dus cd moet een builtin zijn. Hetzelfde geldt voor alles wat de eigen toestand van de shell moet wijzigen, zoals export en umask.

Onder de motorkap doet de shell de daadwerkelijke verplaatsing via een enkele kernel-systeemaanroep genaamd chdir() ("change directory"). De huidige werkmap is geen uitvinding van de shell; het is een eigenschap die de kernel voor elk proces bijhoudt. Wanneer je cd /var/log typt, roept de shell chdir("/var/log") aan, en werkt de kernel de eigen huidige map van het shell-proces bij. Omdat een kindproces een kopie van die map erft maar nooit bij zijn ouder kan komen, is de builtin de enige plek waar die aanroep zinvol kan gebeuren.

6.2 De directory-stack: pushd, popd, dirs

Waar cd - een enkele vorige map onthoudt, onthoudt de directory-stack een hele stapel. pushd ("push directory") verplaatst je naar een nieuwe map en bewaart je huidige map bovenop een stapel. popd ("pop directory") verwijdert het bovenste item en brengt je ernaar terug. dirs toont de stapel.

$ cd /usr
$ pushd /etc         # ga naar /etc, onthoud /usr
/etc /usr
$ pushd /var         # ga naar /var, onthoud /etc en /usr
/var /etc /usr
$ dirs -v            # toon de stapel, genummerd
 0  /var
 1  /etc
 2  /usr
$ popd               # verwijder /var, ga terug naar /etc
/etc /usr

Zo maak je een korte omweg zonder je plek kwijt te raken. Je doet pushd naar een andere map, verricht een kleine klus, en popd gaat rechtstreeks terug naar waar je was. Bij een diepe taak met veel sprongen wint de stapel het van paden uit je hoofd onthouden.

6.3 Logisch versus fysiek: -L en -P

Symbolische links laten een map binnen een andere verschijnen. Dat roept een subtiele vraag op: wanneer je via een symlink cd doet en dan cd .. typt, waar moet "omhoog" je dan brengen? Terug langs de weg die je kwam, of omhoog in de echte map op schijf?

Standaard is cd logisch (de optie -L, kort voor logical): het onthoudt het pad dat je typte, symlinks en al. De optie -P (kort voor physical) laat cd eerst elke symlink oplossen, zodat je in de echte map op schijf zit.

$ ln -s /var/www/html site   # "site" is een link naar /var/www/html
$ cd site
$ pwd
/home/peter/site             # logisch: het pad dat je volgde
$ pwd -P
/var/www/html                # fysiek: de echte locatie

$ cd ..                      # logisch: terug naar /home/peter
$ cd -P site && cd ..        # fysiek: omhoog van /var/www/html naar /var/www

Meestal is de logische standaard wat je wilt, omdat die overeenkomt met hoe je er kwam. Grijp naar cd -P wanneer je geeft om de echte locatie op schijf, bijvoorbeeld in een script dat niet in de war mag raken van een pad met een symlink.

8. Best practices

• Leer cd - vandaag nog. Wisselen tussen twee mappen met cd - bespaart meer toetsaanslagen dan bijna elke andere truc. Maak dit als eerste automatisch.
• Gebruik pushd en popd voor omwegen. Als je even een andere map in moet en meteen terug wilt, houdt de directory-stack je plek voor je vast.
• Leun op Tab-aanvulling. Typ een paar letters en druk op Tab. Het is sneller en het voorkomt typefouten in lange paden.
• Stel CDPATH in voor mappen die je voortdurend bezoekt, en neem altijd . op in de lijst zodat een nabije map alsnog wint.
• Gebruik source, geen uitvoering, wanneer een script je shell moet verplaatsen. Een gewone ./script.sh wijzigt alleen de eigen map van het script.
• Grijp naar de documentatie. Omdat cd een builtin is, zit de handleiding in de shell, niet in een aparte pagina.

$ help cd           # de ingebouwde hulp voor cd (Bash)
$ help pushd        # en voor de directory-stack
$ man bash          # de volledige shell-handleiding, met een sectie SHELL BUILTINS

Merk op dat man cd meestal "No manual entry" zegt, juist omdat cd geen zelfstandig programma is. Gebruik in plaats daarvan help cd.

10. Samenvatting

Het commando cd lijkt triviaal, maar het is een deur naar hoe Unix-processen en het bestandssysteem echt werken.

• cd betekent "change directory". Het verplaatst de huidige werkmap van je shell, de plek waarvandaan elk ander commando werkt.
• Het kan geen gewoon programma zijn, omdat een kindproces de map van zijn ouder niet kan wijzigen. Daarom is cd een shell-builtin.
• Kale cd gaat naar home, cd .. gaat omhoog, cd - springt terug naar de vorige map, en ~ is een afkorting voor home.
• CDPATH geeft een relatieve cd een zoekpad; cdable_vars laat een variabelenaam voor een map staan.
• pushd, popd en dirs beheren een stapel mappen om omwegen te maken zonder je plek kwijt te raken.
• -L (logisch, de standaard) volgt het pad dat je typte; -P (fysiek) lost symlinks op naar de echte locatie op schijf.
• Een cd in een script verplaatst alleen dat script; gebruik source om je eigen shell te verplaatsen.
• De hulp zit in de shell: help cd, niet man cd.

Dit is het handige overzicht om te bewaren:

cd DIR       ga naar een map
cd           ga naar je home-map
cd ~/x       ga naar map x binnen home
cd ..        ga een niveau omhoog
cd -         spring terug naar de vorige map
pushd DIR    ga erheen en bewaar de oude plek op de stapel
popd         keer terug naar de laatst bewaarde plek
dirs -v      toon de directory-stack, genummerd
cd -P DIR    ga de echte map binnen, symlinks opgelost
help cd      de ingebouwde handleiding

Kleine commando's als cd verbergen verrassend veel van hoe Linux is opgebouwd. Als je servers zich gedragen op manieren die moeilijk te verklaren zijn, of als je een opzet wilt die dagelijks makkelijker te beheren is, loont het vaak om goed naar de basis te kijken. Dat is precies het soort werk waar ik graag bij help.