Linux commando: mv

Een bestand verplaatsen voelt nog eenvoudiger dan er een kopieren. Je typt mv, de oude naam, de nieuwe naam, en drukt op Enter. Er lijkt niets te gebeuren, en dat is precies de verrassing: op dezelfde schijf verplaatst mv geen enkele byte van je gegevens. Het verandert een naam in een lijst en is meteen klaar, of het bestand nu twee kilobyte of tweehonderd gigabyte is. Datzelfde commando hernoemt ook bestanden, overschrijft stilletjes alles wat in de weg staat, en heeft geen ongedaan-maken. mv goed leren betekent leren wat een bestandsnaam in Linux echt is.

2. Waar komt de naam vandaan?

De naam mv is simpelweg een afkorting van move (verplaatsen). 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.

mv  =  MoVe

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 mv en niet move. Diezelfde reflex gaf ons cp (copy), rm (remove) en ls (list): een hele woordenschat van werkwoorden van twee letters.

Een klein punt van verwarring is dat mv ook bestanden hernoemt, terwijl er voor het alledaagse geval geen apart rename-commando is; hernoemen is gewoon een bestand naar een nieuwe naam in dezelfde map verplaatsen. De handleiding zegt het zelfs in de titel: "move (rename) files". Als je ooit naar Windows overstapt, let dan op dat de shell daar de klus splitst in move en rename; Unix behandelt ze als een.

4. Eenvoudige toepassingen

4.1 Een bestand hernoemen

Geef mv een bron en een nieuwe naam, en het hernoemt het 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.

$ mv notes.txt notes-final.txt
$ ls
notes-final.txt

Merk op dat de oude naam weg is. Anders dan cp, dat je met twee bestanden achterlaat, laat mv je met een achter: hetzelfde bestand onder een nieuw label.

4.2 Een bestand naar een map verplaatsen

Als de bestemming een bestaande map is, zet mv het bestand erin en behoudt het de oorspronkelijke bestandsnaam. Dit is de meest voorkomende alledaagse toepassing: iets wegbergen in een map.

$ mv report.txt /home/peter/archive/
$ ls /home/peter/archive/
report.txt

De schuine streep aan het eind van archive/ is een goede gewoonte: het maakt je bedoeling duidelijk en, als je de mapnaam verkeerd typt, faalt mv luidruchtig in plaats van report.txt stilletjes te hernoemen naar een bestand dat archive heet.

4.3 Meerdere bestanden tegelijk verplaatsen

Wanneer je meer dan twee argumenten geeft, behandelt mv het laatste als een bestemmingsmap en verplaatst het elk bestand daarvoor daarin. Hier telt de regel "het laatste argument is de bestemming" echt.

$ mv index.html style.css script.js /var/www/site/

Alle drie de bestanden landen in /var/www/site/. Als dat laatste argument geen bestaande map is, weigert mv en drukt het een fout af, wat een handig vangnet is:

$ mv a.txt b.txt nodir
mv: target 'nodir': No such file or directory

4.4 Een map verplaatsen: geen -r nodig

Hier is het eerste echte verschil met cp. Om een map te kopieren moet je -r toevoegen, want een map kopieren betekent alles erin verdubbelen. Een map verplaatsen heeft zo'n optie niet nodig. Omdat een verplaatsing op hetzelfde bestandssysteem maar een naam verandert, is een map met tienduizend bestanden verplaatsen net zo onmiddellijk als een bestand verplaatsen.

$ mv project /home/peter/projects/
$ ls /home/peter/projects/
project

De hele boom gaat mee, onmiddellijk, want er is binnenin niets echt verplaatst. Alleen de eigen vermelding van de map is veranderd om naar een nieuwe ouder te wijzen. Dat ene feit verklaart het meeste van wat mv bijna magisch snel doet aanvoelen.

Een bestand hernoemen en een bestand verplaatsen zijn dezelfde handeling. Of de bestemming nu een naam of een map is, en of die al bestaat, verandert stilletjes waar je bestand belandt. Sectie 6 komt op die valkuil terug.

6. Gevorderde toepassingen

6.1 De mapvalkuil: bestemming bestaat wel of niet

Dit is het meest verwarrende aan het verplaatsen van mappen, en het betrapt iedereen minstens een keer. Wanneer de bestemming een mapnaam is, hangt het resultaat af van of die map al bestaat.

$ mv src dst        # dst does NOT exist: src is renamed to dst
$ mv src dst        # dst DOES exist:     src is moved INSIDE dst
                    #                     giving dst/src

Voer hetzelfde commando in twee verschillende situaties uit en je krijgt twee verschillende indelingen. Als dst niet bestaat, wordt src simpelweg dst. Als dst al bestaat als map, wordt src er binnenin verplaatst, wat dst/src oplevert. Wanneer een script een map op mysterieuze wijze een niveau te diep begraaft, is deze regel bijna altijd de oorzaak.

Om mv te dwingen de bestemming als een gewone naam te behandelen en er nooit "in" te verplaatsen, gebruik je -T (kort voor no-target-directory, geen bestemmingsmap):

$ mv -T src dst     # always rename src to dst, never dst/src

Het spiegelbeeld is -t (kort voor target-directory, bestemmingsmap), dat de bestemmingsmap vooraf benoemt zodat elk ander argument een bron is. Dit is onmisbaar bij het bouwen van commando's met find en xargs, waar de map eerst moet komen:

$ find . -name '*.log' -print0 | xargs -0 mv -t /var/log/archive/

6.2 Het detail van de schuine streep: --strip-trailing-slashes

Een schuine streep aan het eind betekent meestal "dit is een map". Tab-aanvulling in de shell voegt er vaak automatisch een toe. Maar een verdwaalde streep op een bronnaam kan veranderen hoe mv zich gedraagt, vooral bij symbolische links naar mappen. De optie --strip-trailing-slashes verwijdert eventuele schuine strepen aan het eind van de bronargumenten, zodat ze als gewone namen worden behandeld.

$ mv --strip-trailing-slashes linkdir/ newname

Je zult dit zelden met de hand nodig hebben, maar het is goed te weten dat het bestaat wanneer een mv in een script zich vreemd gedraagt bij namen waar een aanvulling een streep aan heeft toegevoegd.

6.3 Verplaatsen is hernoemen, dus rechten gaan mee

Omdat een verplaatsing op hetzelfde bestandssysteem nooit een nieuw bestand maakt, houdt het bestand alles: zijn rechten, eigenaar, tijdstempels, uitgebreide attributen en inode-nummer blijven precies zoals ze waren. Er is geen -p-optie op mv zoals bij cp, en die is niet nodig, want er wordt niets opnieuw gemaakt. Zodra mv naar een ander bestandssysteem oversteekt, moet het echter een nieuw bestand op de bestemming maken, en dan doet het zijn best om die attributen op de kopie te reproduceren voordat het het origineel verwijdert.

Daarom overleeft het inode-nummer, dat je met ls -i kunt zien, een hernoeming op dezelfde schijf, maar verandert het na een verplaatsing over schijven heen: in het eerste geval is het hetzelfde bestand, en in het tweede een nieuw.

6.4 Wie een bestand mag verplaatsen

Omdat een verplaatsing mapvermeldingen bewerkt in plaats van het bestand zelf, zit het recht dat telt op de mappen, niet op het bestand. Om een bestand te hernoemen of te verplaatsen heb je schrijf- en uitvoerrecht nodig op de bronmap, en op de bestemmingsmap ook. Je hoeft het bestand niet te bezitten, en je hoeft niet eens toestemming te hebben om de inhoud te lezen of te schrijven. Dit verrast veel nieuwelingen.

$ ls -l
-rw-r--r-- 1 root root 42 Jul  7 10:00 owned-by-root.txt
$ mv owned-by-root.txt renamed.txt    # works: you have write access to the directory

De ene uitzondering is een map met de sticky bit ingesteld, zoals /tmp. Daar mag alleen de eigenaar van een bestand (of root) het hernoemen of verwijderen, en dat is precies wat gebruikers op een gedeeld systeem tegenhoudt om elkaars bestanden uit /tmp te verplaatsen.

6.5 Een symbolische link verplaatsen

Wanneer de bron een symbolische link is, verplaatst mv de link zelf, niet het bestand waar die naar wijst. Het doelbestand blijft precies waar het is, en de link krijgt gewoon een nieuwe naam of locatie terwijl hij nog steeds naar hetzelfde pad wijst.

$ mv mylink newlink    # the link is renamed; its target is untouched

Merk op dat een symlink zijn doel als pad opslaat, niet als inode. Als dat pad relatief was, kan het verplaatsen van de link naar een andere map hem naar niets laten wijzen, want het relatieve pad wordt nu vanaf een andere plek opgelost.

8. Beste werkwijzen

• Ga ervan uit dat de bestemming wordt overschreven. Vraag je voor mv a b af wat b nu bevat. Er is geen ongedaan-maken. Gebruik -i als je met de hand werkt en niet zeker bent.
• Gebruik "tijdelijk bestand, dan mv" om belangrijke bestanden bij te werken. Schrijf de nieuwe versie naast het origineel en hernoem die op zijn plaats; de atomaire wissel betekent dat lezers nooit een half geschreven bestand zien.
• Let op de mapvalkuil. Bij mv src dst verschilt het resultaat naargelang dst bestaat. Gebruik -T wanneer je "hernoem naar precies deze naam" bedoelt.
• Zet een schuine streep achter een bestemmingsmap. mv file dir/ faalt luidruchtig als dir ontbreekt, in plaats van file stilletjes naar dir te hernoemen.
• Kopieer, verifieer, en verwijder dan bij verplaatsingen over schijven. Een verplaatsing tussen bestandssystemen is een niet-atomaire kopie plus verwijdering; verkies bij grote of belangrijke gegevens rsync en verwijder de bron pas als je het resultaat hebt gecontroleerd.
• Grijp zonder aarzelen naar de handleiding. De gewoonte die beginners van professionals onderscheidt, is man mv typen zodra er een vraag opkomt.

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

10. Samenvatting

Het commando mv lijkt alsof het niets doet, en op dezelfde schijf is dat bijna waar, wat het juist zo'n zuivere les maakt in hoe Linux een bestand van zijn naam scheidt.

• mv is kort voor "move" (verplaatsen). Het hernoemt een bestand of verplaatst het naar een andere plek; beide zijn dezelfde handeling, namelijk veranderen waar een naam naar wijst.
• Op een bestandssysteem verplaatst het alleen de naam, met een atomaire rename(), dus een groot bestand of een hele map verplaatsen is onmiddellijk en heeft geen -r nodig.
• Over bestandssystemen heen kan het niet hernoemen, dus kopieert het elke byte en verwijdert het het origineel, wat tijd kost en niet atomair is.
• Het laatste argument is de bestemming. Naar een bestaande map verplaatsen behoudt de bestandsnaam; meerdere bestanden verplaatsen vereist dat het laatste argument een map is.
• Of de bestemmingsmap al bestaat verandert waar het bestand belandt; gebruik -T om een gewone hernoeming af te dwingen en -t om de bestemmingsmap eerst te benoemen.
• -i vraagt voor het overschrijven, -n slaat bestaande bestanden over, -f forceert, -v toont voortgang, -b bewaart een backup, -u verplaatst alleen nieuwere bestanden.
• Omdat een hernoeming atomair is, is "schrijf een tijdelijk bestand, en mv het dan over het doel" de veilige manier om een bestand bij te werken dat andere programma's lezen.
• Het recht om een bestand te verplaatsen zit op de mappen, niet op het bestand: met schrijfrecht op een map kun je een bestand verplaatsen dat je niet bezit, tenzij de sticky bit (zoals op /tmp) het verbiedt.
• Er is geen ongedaan-maken en geen prullenbak; mv a b vernietigt wat b ook was, stilletjes.
• Weet waar mv ophoudt: rename voor patroonhernoemingen, rsync voor veilige verplaatsingen over schijven of op afstand, cp om het origineel te houden.
• Bij twijfel, typ man mv.

Dit is de snelle referentie om te bewaren:

mv a b               rename a to b (overwrites b silently)
mv a b c dir/        move several files into a directory
mv dir dst/          move a whole directory (no -r needed)
mv -T src dst        rename src to dst, never dst/src
mv -t dir/ a b c     name the target directory first
mv -i a b            ask before overwriting b
mv -n a b            skip if b already exists
mv -b a b            back up the old b as b~ before overwriting
mv -u a b            move only if a is newer than b
mv -- -x.txt dir/    move a file whose name starts with a dash
mv tmp real          the atomic-swap trick for safe file updates

Kleine commando's als mv verbergen een verrassende hoeveelheid van hoe Linux is gebouwd, en een enkele onvoorzichtige verplaatsing 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.