Linux commando: cp

1. De basis

De taak van cp is om een bestand te kopieren: het leest de bytes van een bron en schrijft een onafhankelijke kopie naar een bestemming. Het origineel blijft precies waar het was, onaangeroerd. Daarna heb je twee losse bestanden die toevallig dezelfde inhoud bevatten maar hun eigen leven leiden; verander het ene en het andere beweegt niet mee.

Die onafhankelijkheid is het hele punt, en het is wat cp onderscheidt van zijn neefje mv. Wanneer je een bestand verplaatst binnen hetzelfde bestandssysteem, wordt er helemaal niets gekopieerd; alleen de naam verandert. Wanneer je een bestand kopieert, worden de gegevens echt opnieuw gelezen en geschreven, dus een kopie van een groot bestand kost echte tijd en echte ruimte. Houd dat verschil in gedachten; het verklaart bijna alles wat cp doet.

Het commando leest van links naar rechts: het laatste argument is de bestemming, en alles daarvoor is een bron.

$ cp report.txt report-backup.txt

Het commando dat iedereen op dag een leert. Achter die twee letters schuilt een verrassende hoeveelheid zorg over wat "een kopie" echt betekent: rechten, tijdstempels, symbolische links, mappen, en of het oude bestand op de bestemming blijft bestaan.

Dit artikel begint met de eenvoudigst mogelijke kopie en bouwt op naar het kopieren van hele mapbomen, het behouden van metadata, backups maken in plaats van overschrijven, en de copy-on-write-truc die enorme kopieen bijna onmiddellijk laat voelen. Aan het einde weet je niet alleen hoe je een bestand kopieert, maar precies wanneer cp er een gaat vernietigen.

Het juiste denkmodel: cp maakt een tweede, onafhankelijk bestand. Het origineel is veilig; het gevaar zit altijd bij de bestemming, want standaard overschrijft cp alles wat daar al staat, zonder een woord.

3. Een korte geschiedenis

Het commando cp is een van de originele Unix-gereedschappen. Het werd geleverd met Unix 1st Edition bij Bell Labs in 1971, naast cat, mv en rm, en is sindsdien aanwezig op elk Unix-achtig systeem: Linux, macOS, de BSD's, Solaris en AIX. Het kernidee, "lees een bestand en schrijf het weg onder een nieuwe naam", is in ruim vijftig jaar niet veranderd.

Wat wel is veranderd, is wat er onder de motorkap gebeurt. Decennialang was cp een simpele lus die een blok bytes las en het weer wegschreef. Moderne versies zijn veel slimmer: ze kunnen de kernel vragen om gegevens te kopieren zonder ze door het programma te slepen, ze kunnen lange reeksen nullen herkennen en overslaan (sparse-bestanden), en op sommige bestandssystemen delen ze gegevensblokken tussen de bron en de kopie totdat een van beide verandert.

Er zijn twee families die je in de praktijk tegenkomt. De meeste Linux-systemen draaien de GNU coreutils-versie van cp. macOS en de BSD's leveren de BSD-versie. Ze zijn het eens over de alledaagse opties zoals -r, -i, -p en -f. De verschillen zitten in de extra's: GNU voegt lange opties toe (bijvoorbeeld --preserve, --parents en --reflink) die BSD anders spelt of mist. Dit artikel gebruikt de GNU-versie, die je op vrijwel elke Linux-server vindt.

5. Gematigde toepassingen

5.1 Niet stilletjes overschrijven: -i en -n

Standaard overschrijft cp een bestaand bestemmingsbestand zonder waarschuwing. Als report-backup.txt al iets belangrijks bevat, wist een onvoorzichtige kopie het uit. Twee opties maken cp voorzichtiger.

De optie -i (kort voor interactive, interactief) vraagt het voordat het overschrijft, zodat je een fout kunt tegenhouden:

$ cp -i new.txt report-backup.txt
cp: overwrite 'report-backup.txt'? n

De optie -n (kort voor no-clobber, niet-overschrijven) is de stille versie: het slaat elk bestand over dat al bestaat en vraagt nooit, wat handig is in scripts waar je alleen ontbrekende bestanden wilt aanvullen.

$ cp -n new.txt report-backup.txt      # existing file is left untouched

5.2 Zien wat er gebeurt: -v

De optie -v (kort voor verbose, uitgebreid) drukt een regel per gekopieerd bestand af. Bij een grote recursieve kopie verandert dit een stille, verontrustende pauze in een zichtbare lijst met voortgang.

$ cp -rv photos /backup/
'photos/2023' -> '/backup/photos/2023'
'photos/2023/beach.jpg' -> '/backup/photos/2023/beach.jpg'
'photos/2024/city.jpg' -> '/backup/photos/2024/city.jpg'

5.3 De metadata behouden: -p

Een gewone kopie is een nieuw bestand. Het krijgt een verse wijzigingstijd (nu) en neemt zijn rechten over van je huidige instellingen, niet van het origineel. Meestal is dat prima. Voor backups en systeembestanden niet: vaak wil je dat de kopie de rechten, eigenaar en tijdstempels van het origineel behoudt. De optie -p (kort voor preserve, behouden) doet precies dat.

$ cp file.conf copy.conf          # copy has a new timestamp and default mode
$ cp -p file.conf copy-kept.conf  # copy keeps mode, owner, and times

Je kunt om meer of minder vragen met de lange vorm --preserve=, waarbij je kiest uit mode, ownership, timestamps, links en all:

$ cp --preserve=timestamps a.log b.log   # keep only the times

5.4 De archief-snelkoppeling: -a

Wanneer je een mapboom kopieert die symbolische links, speciale rechten en bestanden bevat die je precies zo wilt laten, is het uittypen van elke behoud-optie omslachtig. De optie -a (kort voor archive, archief) bundelt de juiste standaardinstellingen: het is hetzelfde als -dR --preserve=all. Het kopieert recursief, behoudt elk attribuut, en verandert symbolische links niet in echte bestanden.

$ cp -a /etc/nginx /root/nginx-backup   # a faithful, complete copy

"Elk attribuut" betekent meer dan mode, eigenaar en tijdstempels. --preserve=all (en dus -a) probeert ook de uitgebreide attributen (xattr), ACL's en de SELinux-beveiligingscontext te behouden, voor zover het bestemmingsbestandssysteem ze ondersteunt. Die dekking is de reden dat cp -a het dichtst bij "maak een exacte kopie van deze boom" komt, en waarom het de juiste keuze is om een map onveranderd te backuppen.

Er zit wel een grens aan. cp behoudt wat het lokale bestandssysteem begrijpt; kopieren naar een bestandssysteem of een andere machine die rechten anders behandelt, kan een deel van die metadata stilletjes laten vallen. Voor getrouwe kopieen tussen Linux-systemen grijpen veel beheerders nog steeds naar rsync (met -a) of tar, waar sectie 7 op terugkomt.

7. Iets wat de meeste gebruikers niet weten

7.1 10 GB onmiddellijk kopieren: --reflink en copy-on-write

Hier komt het echt verrassende deel. Op een modern copy-on-write-bestandssysteem zoals Btrfs of XFS hoeft cp de gegevens helemaal niet te dupliceren. Met --reflink maakt het een kopie die dezelfde gegevensblokken deelt als het origineel. De twee bestanden zien er volledig onafhankelijk uit, maar op schijf wijzen ze naar dezelfde bytes totdat een van beide wordt gewijzigd. Pas dan, en alleen voor de blokken die daadwerkelijk veranderen, worden er nieuwe gegevens geschreven. Dit heet copy-on-write.

$ cp --reflink=always huge.img huge-copy.img   # near-instant, uses ~0 extra space

Een virtuele-machine-image van 10 GB op deze manier kopieren is in een fractie van een seconde klaar en voegt bijna niets toe aan je schijfgebruik. Sinds coreutils 9.0 (2021) probeert GNU cp automatisch een reflink (--reflink=auto) en valt het stilletjes terug op een gewone kopie op bestandssystemen die het niet aankunnen, dus op het juiste bestandssysteem krijg je dit misschien al gratis. macOS met APFS ondersteunt dezelfde copy-on-write-truc.

Een reflink-kopie is geen link en geen snapshot: het is een echt, apart bestand dat toevallig opslag deelt totdat je het bewerkt. Het geeft je de veiligheid van een kopie met de snelheid en ruimte van een link.

7.2 cp leest en schrijft; mv doet vaak geen van beide

Mensen behandelen cp en mv als een bijeenhorend paar, maar onder de motorkap zijn ze heel verschillend. Binnen een enkel bestandssysteem verandert mv alleen een naam in een map; de gegevens bewegen nooit, en daarom is een enorm bestand verplaatsen onmiddellijk. cp leest altijd elke byte van de bron en schrijft die weer weg, dus datzelfde enorme bestand kopieren kost echte tijd en verdubbelt de gebruikte ruimte. Zodra mv naar een ander bestandssysteem gaat, kan het echter niet gewoon hernoemen, dus valt het terug op het kopieren van de gegevens en daarna het verwijderen van het origineel, wat precies is wat cp doet plus een rm.

Daarom laat een kopie het origineel op zijn plaats en een verplaatsing niet, en daarom kan een onderbroken mv tussen schijven gevaarlijker zijn dan een onderbroken cp.

7.3 Er is geen ongedaan maken, en de bron is niet altijd veilig

Het beroemde gevaar van cp zit bij de bestemming: cp a b vernietigt wat b ook was, zonder bevestiging en zonder prullenbak. Er is geen ongedaan maken. Maar er is een subtielere valkuil. Een bestand op zichzelf kopieren wordt opgemerkt en geweigerd:

$ cp a a
cp: 'a' and 'a' are the same file

Toch kan de shell dat voor cp verbergen. Een glob zoals cp * backup.txt in een map waar backup.txt al onder * valt, kan de bestemming als bron meesturen, en gecombineerd met andere bestanden is het resultaat zelden wat je bedoelde. Wanneer je met jokertekens kopieert, kijk dan goed naar wat de * daadwerkelijk uitbreidt.

7.4 Onder de motorkap: wat "kopieren" echt kost

Een traditionele cp is een kleine lus: open() de bron, open() (of maak) de bestemming, lees dan herhaaldelijk een blok bytes met read() en schrijf het weg met write() tot het einde van het bestand, en close() ten slotte beide. Moderne cp verbetert dit op drie manieren die het weten waard zijn.

Je hoeft niets hiervan met de hand aan te vragen; GNU cp kiest de snelste veilige methode voor het bestandssysteem waarop je zit. De sparse-afhandeling staat standaard op --sparse=auto, maar je kunt het forceren met --sparse=always of uitschakelen met --sparse=never. De les is dat "kopieer dit bestand" niet een vaste bewerking is. Wat het kost aan tijd en ruimte hangt af van het bestandssysteem onder je voeten.

7.5 Weten waar cp stopt

Een deel van expertise is weten wanneer een ander gereedschap beter past. cp is perfect voor een eenmalige, lokale kopie. Daarbuiten nemen anderen het over.

Leer toch eerst cp. Het staat op elke machine waarop je ooit zult inloggen, ook op een reddingsshell, en alles wat rsync en tar doen is gebouwd op hetzelfde idee van een bron lezen en een getrouwe kopie schrijven.

9. Veelgemaakte fouten

9.1 Drie veelvoorkomende mythes

9.2 Andere valkuilen om te vermijden

• Overschrijven zonder het te merken. cp new important vernietigt important zonder waarschuwing. Er is geen prullenbak en geen ongedaan maken.
• Vergeten van -r voor een map. cp dir dst faalt met "omitting directory". Voeg -r toe, en let dan op de bestaat-of-niet-regel.
• De dubbele-nesting-verrassing. cp -r src dst een tweede keer uitvoeren levert dst/src op, niet nog een dst. Gebruik src/. om de inhoud te kopieren.
• Rechten verliezen op systeembestanden. Een gewone kopie van een config of script krijgt je standaard-mode en een nieuw tijdstempel. Gebruik -p of -a wanneer dat telt.
• Een kopie op dezelfde schijf als backup vertrouwen. Als de schijf faalt, gaan beide bestanden samen. Een echte backup staat op aparte opslag.