Linux commando: rm

Van alle alledaagse Linux-commando's is rm degene die een moment respect verdient voordat je op Enter drukt. Het verwijdert bestanden, het verwijdert mappen vol bestanden, en het doet dit alles onmiddellijk, stilletjes, en zonder prullenbak om achteraf iets uit op te vissen. Er is geen ongedaan-maken. Toch is de grootste verrassing aan rm dat het eigenlijk helemaal niets "wist": het verwijdert een naam, en de gegevens blijven vaak nog lang op de schijf staan nadat je dacht dat ze weg waren. rm goed leren betekent leren wat verwijderen in Linux echt is, en precies waar het gevaar zit.

2. Waar komt de naam vandaan?

De naam rm is simpelweg een afkorting van remove (verwijderen). Zoals bij de meeste vroege Unix-commando's zit er geen verborgen betekenis in; de twee letters zijn de eerste en laatste medeklinker van het woord.

rm  =  ReMove

Het vroege Unix werd getypt op trage teletype-terminals die elk teken op papier afdrukten, dus korte commandonamen bespaarden zowel typtijd als papier. Daarom is het commando rm en niet remove of delete. Diezelfde reflex gaf ons cp (copy), mv (move) en ls (list): een hele woordenschat van werkwoorden van twee letters.

Het is de moeite waard te letten op het woord dat gekozen is. Het commando heet niet delete of erase, en dat is geen toeval. Onder de motorkap roept rm een systeemfunctie aan met de naam unlink(), en "unlink" (ontkoppelen) is een veel eerlijkere beschrijving van wat er gebeurt: een link tussen een naam en wat gegevens wordt verbroken, niet de gegevens zelf. Er is zelfs een apart laag-niveau commando met de naam unlink dat precies een naam verwijdert en niets meer. Houd het woord "unlink" in gedachten; het verklaart het meest verrassende gedrag van rm verderop in dit artikel.

4. Eenvoudige toepassingen

4.1 Een enkel bestand verwijderen

Geef rm een bestandsnaam en het verwijdert dat bestand. In de voorbeelden hieronder is de regel die met $ begint wat je typt; een commando dat niets afdrukt, is gewoon geslaagd, wat de normale Unix-manier is om "alles goed" te zeggen.

$ rm notes.txt
$ ls
report.txt  todo.txt

Het bestand notes.txt is meteen uit de lijst verdwenen. Er is geen bevestiging en geen samenvatting, want in de Unix-traditie betekent stilte succes.

4.2 Meerdere bestanden tegelijk verwijderen

Je kunt zoveel namen meegeven als je wilt, en rm verwijdert er elk. Hier worden jokertekens zowel krachtig als gevaarlijk, een punt waar sectie 6 op terugkomt.

$ rm draft1.txt draft2.txt draft3.txt
$ rm *.log                    # remove every file ending in .log

De shell vult *.log in tot de bijpassende bestandsnamen voordat rm draait, dus rm ziet de ster nooit; het krijgt gewoon een lijst met namen. Dat detail telt enorm zodra het patroon breed is.

4.3 Eerst vragen: -i

Omdat er geen ongedaan-maken is, is de veiligste gewoonte bij het met de hand verwijderen om rm te laten vragen. De optie -i (kort voor interactive, interactief) vraagt het voor elke afzonderlijke verwijdering, en verwijdert alleen de bestanden waar je y op antwoordt.

$ rm -i report.txt
rm: remove regular file 'report.txt'? y

Veel systemen aliassen rm naar rm -i voor de root-gebruiker om precies deze reden. Het verandert een stil, onmiddellijk commando in een dat je een kans geeft om te stoppen.

4.4 Zien wat er gebeurt: -v

De optie -v (kort voor verbose, uitgebreid) drukt een regel per verwijderd bestand af. Bij een verwijdering in bulk verandert dit een stille operatie in een zichtbare lijst van precies wat er verdween, wat geruststellend is wanneer er een jokerteken bij komt kijken.

$ rm -v *.tmp
removed 'cache.tmp'
removed 'session.tmp'

Het woord removed bevestigt elke verwijdering achteraf. -v combineren met een recursieve verwijdering is een goede manier om een grote operatie te volgen en die vroeg te betrappen als die het verkeerde begint aan te raken.

6. Gevorderde toepassingen

6.1 Het beroemdste gevaar: rm -rf /

Het commando waar legendes van gemaakt zijn, is rm -rf /: verwijder, recursief en met dwang, beginnend bij de wortel van het hele bestandssysteem. Op oud Unix deed het precies dat en vernietigde het het systeem. Modern GNU rm weigert het standaard dankzij een ingebouwde bescherming genaamd --preserve-root.

$ rm -rf /
rm: it is dangerous to operate recursively on '/'
rm: use --no-preserve-root to override this failsafe

Dat vangnet staat standaard aan; je zou --no-preserve-root met opzet moeten toevoegen om het uit te schakelen, wat een sterk signaal is dat je op het punt staat iets te doen waar je spijt van krijgt. Er is zelfs een strengere vorm, --preserve-root=all, die ook elk argument weigert dat op een andere aangekoppelde schijf staat dan zijn ouder.

De bescherming is echter smal. Het bewaakt de letterlijke /, maar het bewaakt niet rm -rf /home/olduser of rm -rf . in de verkeerde map. De echte les is niet om op het vangnet te leunen, maar om het hele commando te lezen voordat je het uitvoert, vooral het pad meteen na -rf.

6.2 Wie een bestand mag verwijderen

Dit verrast veel nieuwelingen: om een bestand te verwijderen hoef je het niet te bezitten, en je hebt geen toestemming nodig om de inhoud te lezen of te schrijven. Omdat het verwijderen van een bestand de map bewerkt waarin het staat, is het recht dat telt schrijf- en uitvoerrecht op de omvattende map, niet op het bestand.

$ ls -l
-r--r--r-- 1 root root 42 Jul  7 10:00 owned-by-root.txt
$ rm owned-by-root.txt             # works if you can write the directory,
                                   # even though the file is read-only and root's

Als het bestand zelf schrijfbeveiligd is, merkt rm dat op en vraagt het uit beleefdheid om bevestiging, maar het kan het alsnog verwijderen zodra je akkoord gaat. De ene echte uitzondering is een map met de sticky bit ingesteld, zoals /tmp. Daar mag alleen de eigenaar van een bestand (of root) het verwijderen, en dat is precies wat gebruikers op een gedeeld systeem tegenhoudt om elkaars bestanden uit /tmp te verwijderen.

6.3 Bestandsnamen die met een streepje beginnen

Een bestand dat -rf of -file.txt heet, ziet er voor rm precies uit als een optie, dus het commando leest het als een vlag en faalt ofwel, of erger, doet iets wat je niet bedoelde. De oplossing is de markering --, die rm vertelt dat alles erna een bestandsnaam is, geen optie.

$ rm -- -file.txt                  # everything after -- is treated as a name
$ rm ./-file.txt                   # or hide the dash behind a ./ path

Dit is geen zeldzaam randgeval; een verkeerd getypte omleiding of een slecht geschreven script kan gemakkelijk een bestand maken waarvan de naam met een streepje begint, en -- is de nette manier om het te verwijderen.

6.4 Een recursieve verwijdering op een schijf houden: --one-file-system

Wanneer je een grote boom verwijdert die andere schijven eronder aangekoppeld heeft, daalt een gewone rm -r vrolijk in die aankoppelpunten af en begint het ook hun inhoud te verwijderen. De optie --one-file-system vertelt rm om elke map over te slaan die op een ander bestandssysteem staat dan waar de verwijdering begon.

$ rm -rf --one-file-system /mnt/oldroot   # will not wander into other mounts

Dit is een professionele gewoonte bij het opruimen van een oude systeemwortel of een chroot met /proc, /sys of een gegevensschijf eronder aangekoppeld. Het trekt een stevige lijn rond precies wat de verwijdering mag aanraken.

6.5 De valkuilen van jokertekens en lege variabelen

Omdat de shell jokertekens invult voordat rm draait, zit het grootste gevaar bij rm niet in het commando zelf maar in wat de shell het aanreikt. Een verdwaalde spatie verandert rm -rf ./tmp in rm -rf . /tmp, wat ook de huidige map verwijdert. Een jokerteken dat meer matcht dan je verwacht, verwijdert dat allemaal in een keer.

$ rm -rf $DIR/*                    # if $DIR is empty, this becomes rm -rf /*

Die laatste regel is een klassieke script-ramp. Als de variabele DIR niet gezet of leeg is, valt het commando uiteen in rm -rf /* en probeert het het systeem te wissen. Defensieve scripts quoten en controleren hun variabelen eerst, bijvoorbeeld met [ -n "$DIR" ] voor elk destructief commando, en veel scripts gebruiken set -u zodat een niet-gezette variabele het script stopt in plaats van uiteen te vallen in niets.

Quoten draait de betekenis volledig om, wat nuttig is om te begrijpen. Een ongequote rm *.jpg laat de shell de ster invullen tot elke bijpassende bestandsnaam. Maar rm "*.jpg", met quotes, verbergt de ster voor de shell, dus rm ontvangt de vier tekens *.jpg letterlijk en probeert een enkel bestand te verwijderen waarvan de echte naam *.jpg is. Dit is precies hoe je een bestand verwijdert dat per ongeluk met een ster in zijn naam is gemaakt, en het is een goede herinnering dat rm je jokertekens nooit ziet; de shell wel.

Het gevaarlijke deel van rm is bijna nooit rm zelf. Het is de shell die beslist waar * en $VAR in uiteenvallen voordat rm ze ooit ziet. Kijk naar waar het commando in uiteenvalt, niet alleen naar wat je typte.

6.6 Een symbolische link verwijderen

Wanneer het doel een symbolische link is, verwijdert rm de link zelf, niet het bestand waar die naar wijst. Het bestand aan de andere kant blijft precies waar het is; alleen de kleine verwijzing verdwijnt. Dit is het veilige, verwachte gedrag, en het betekent dat je een kapotte of ongewenste snelkoppeling kunt opruimen zonder enig risico voor de echte gegevens.

$ rm mylink                        # deletes the link; its target is untouched

Een detail betrapt mensen wanneer de link naar een map wijst. Een schuine streep aan het eind verandert wat je benoemt. Zonder streep benoem je de link; met een streep benoem je de map erachter, en omdat rm een map niet zonder -r verwijdert, weigert het.

$ rm linkdir/
rm: cannot remove 'linkdir/': Is a directory
$ rm linkdir                       # no slash: removes the symlink itself

Tab-aanvulling in de shell voegt die schuine streep aan het eind graag automatisch toe, dus als een verwijdering van een map-symlink faalt met "Is a directory", haal de streep dan weg en probeer opnieuw.

8. Beste werkwijzen

• Lees het hele commando voordat je op Enter drukt. Bij rm is het pad meteen na -rf het pad dat telt. Er is geen ongedaan-maken en geen prullenbak.
• Verkies rm -I voor werk met de hand. Het vraagt een keer voor een grote of recursieve verwijdering zonder je op elk bestand te storen, en betrapt het op hol geslagen jokerteken terwijl het uit de weg blijft.
• Kijk eerst naar waar een jokerteken in uiteenvalt. Voer ls *.log uit voor rm *.log, zodat je precies de lijst verwijdert die je net zag.
• Vertrouw nooit een ongequote variabele in een destructief commando. Een lege $DIR verandert rm -rf $DIR/* in een systeemwis; quote hem, controleer of hij gezet is, en gebruik set -u in scripts.
• Gebruik --one-file-system bij het leegmaken van een boom met aankoppelpunten erin. Het stopt een recursieve verwijdering om naar andere schijven af te dwalen.
• Behandel rm niet als een veilige wis. Het verwijdert alleen de naam en laat de bytes herstelbaar. shred kan ze overschrijven, maar op SSD's en copy-on-write-bestandssystemen is dat onbetrouwbaar, dus gebruik versleuteling wanneer de gegevens echt gevoelig zijn.
• Grijp zonder aarzelen naar de handleiding. De gewoonte die beginners van professionals onderscheidt, is man rm typen zodra er een vraag opkomt.

$ man rm                            # the full manual page
$ rm --help                         # a quick flag summary (GNU)
$ info coreutils 'rm invocation'    # the verbose GNU manual

10. Samenvatting

Het commando rm is kort, bot en meedogenloos, en dat is juist wat het zo'n heldere les maakt in hoe Linux een bestand van zijn naam en zijn gegevens scheidt.

• rm is kort voor "remove" (verwijderen). Het verwijdert bestanden door een naam te ontkoppelen, niet door de gegevens op de schijf te wissen.
• Er is geen ongedaan-maken en geen prullenbak; een verwijderd bestand is meteen uit zicht, standaard zonder bevestiging.
• -i vraagt voor elk bestand, -I vraagt een keer voor een grote of recursieve verwijdering, -v toont elke verwijdering, -f forceert en onderdrukt fouten.
• -r (ook -R, --recursive) verwijdert een map en alles erin; -d en rmdir verwijderen alleen lege mappen.
• Modern GNU rm weigert rm -rf / standaard via --preserve-root, maar die bescherming dekt de verkeerde submap niet.
• Het recht om een bestand te verwijderen zit op de omvattende map, niet op het bestand: met schrijfrecht op een map kun je een bestand verwijderen dat je niet bezit, tenzij de sticky bit (zoals op /tmp) het verbiedt.
• Een van de hard links verwijderen verwijdert het bestand niet als er andere links overblijven; de gegevens worden pas vrijgegeven wanneer de link count nul bereikt en geen programma het meer open houdt.
• Een verwijderd bestand is niet gewist: de blokken worden slechts vrijgegeven en zijn te herstellen tot ze hergebruikt worden. shred kan ze overschrijven, maar op SSD's en copy-on-write-schijven is versleuteling de betrouwbare bescherming.
• Het echte gevaar is de shell: jokertekens en lege variabelen kunnen een klein commando in een ramp veranderen voordat rm ooit draait.
• Weet waar rm ophoudt: shred om echt te wissen, find -delete voor verwijderingen op regels, rmdir voor lege mappen, trash-cli voor een herstelbare prullenbak.
• Bij twijfel, typ man rm.

Dit is de snelle referentie om te bewaren:

rm file              remove a single file (no undo, no trash)
rm f1 f2 f3          remove several files
rm *.log             remove every file matching a wildcard
rm -i file           ask before every removal
rm -I *.mp4          ask once before a large or recursive delete
rm -v file           show each file as it is removed
rm -r dir            remove a directory and all its contents
rm -d dir            remove a directory only if it is empty
rm -f file           force: no prompt, no error if missing
rm -rf dir           remove a tree with no questions asked
rm -- -file.txt      remove a file whose name starts with a dash
rm -rf --one-file-system dir   do not cross into mounted disks
shred -u file        overwrite then remove (unreliable on SSDs/CoW)

Kleine commando's als rm verbergen een verrassende hoeveelheid van hoe Linux is gebouwd, en een enkele onvoorzichtige verwijdering kan uren werk ongedaan maken zonder weg terug. Als je servers ertoe doen en je ze wilt laten onderhouden door iemand die begrijpt wat er onder de motorkap echt gebeurt, dan is dat precies het soort werk waar ik graag mee help.