Fullbeskrivning av dd: Skillnad mellan sidversioner

Från Wiki.linux.se
Hoppa till navigering Hoppa till sök
(Omdirigerar till Dd)
Märke: Ny omdirigering
 
(2 mellanliggande sidversioner av samma användare visas inte)
Rad 1: Rad 1:
= dd: Konvertera och kopiera en fil =
#REDIRECT [[dd]]
dd kopierar indata till utdata med en föränderlig I/O-blockstorlek, samtidigt som omvandlingar utförs på data. Sammanfattning:
 
<code>dd [operand]...</code>
 
<code>dd alternativ</code>
 
Som standard kopierar [[dd]] standardindata till standardutdata. För att kopiera, gör dd upprepade gånger följande steg i ordning:
 
De enda alternativen är --help och --version. Se Vanliga alternativ.
 
# Läs ett inmatningsblock.
# Om du konverterar via "synkronisering", lägg efter behov för att möta inmatningsblockets storlek. Pad med mellanslag om du konverterar via "blockera" eller "avblockera", NUL-bytes annars.
# Om 'bs=' ges och ingen konvertering som nämns i steg (4) eller (5) ges, mata ut data som ett enda block och hoppa över alla återstående steg.
# Om "svabb"-omvandlingen ges, byt ut varje par indatabyte. Om indatalängden är udda, bevara den sista indatabyten (eftersom det inte finns något att byta med).
# Om någon av omvandlingarna 'swab', 'block', 'unblock', 'lcase', 'ucase', 'ascii', 'ebcdic' och 'ibm' ges, gör du dessa konverteringar. Dessa konverteringar fungerar oberoende av ingångsblockering och kan hantera poster som spänner över blockgränser.
# Aggregera resulterande data i utdatablock av den specificerade storleken och mata ut varje utdatablock i tur och ordning. Fyll inte på det sista utgångsblocket; den kan vara kortare än vanligt.
[[dd]] accepterar följande operander, vars syntax var inspirerad av DD-satsen (datadefinition) i OS/360 JCL.
 
'''''<nowiki/>'if=fil''''''
 
Läs från fil istället för standardinmatning.
 
'''''<nowiki/>'of=fil''''''
 
Skriv till fil istället för standardutdata. Om inte 'conv=notrunc' ges, trunkera filen innan du skriver den.
 
'''''<nowiki/>'ibs=bytes''''''
 
Ställ in storleken på inmatningsblocket till byte. Detta gör att dd läser byte per block. Standard är 512 byte.
 
'''''<nowiki/>'obs=bytes''''''
 
Ställ in storleken på utdatablocket till byte. Detta gör att dd skriver byte per block. Standard är 512 byte.
 
'''''<nowiki/>'bs=bytes''''''
 
Ställ in både ingångs- och utgångsblockstorlekar till byte. Detta gör att dd läser och skriver byte per block, och åsidosätter alla "ibs" och "obs"-inställningar. Dessutom, om ingen datatransformerande konv operand anges, kopieras indata till utgången så snart den läses, även om den är mindre än blockstorleken.
 
'''''<nowiki/>'cbs=bytes''''''
 
Ställ in konverteringsblockstorleken till byte. När du konverterar poster med variabel längd till poster med fast längd (conv=block) eller omvänt (conv=unblock), använd bytes som fast postlängd.
 
'''''<nowiki/>'skip=n''''''
 
'''''<nowiki/>'iseek=n''''''
 
Hoppa över n 'ibs'-byte-block i inmatningsfilen innan du kopierar. Om n slutar på bokstaven "B", tolka n som ett byteantal snarare än ett blockantal. ('B' och 'iseek=' stavningen är GNU-tillägg till POSIX.)
 
'''''<nowiki/>'seek=n''''''
 
'''''<nowiki/>'oseek=n''''''
 
Hoppa över n 'obs'-byte-block i utdatafilen innan du trunkerar eller kopierar. Om n slutar på bokstaven "B", tolka n som ett byteantal snarare än ett blockantal. ('B' och 'oseek=' stavningen är GNU-tillägg till POSIX.)
 
'''''<nowiki/>'count=n''''''
 
Kopiera n 'ibs'-byte-block från indatafilen, istället för allt till slutet av filen. Om n slutar på bokstaven "B", tolka n som ett byteantal snarare än ett blockantal; detta är en GNU-tillägg till POSIX. Om korta läsningar inträffar, vilket kan vara fallet när man t.ex. läser från ett rör, säkerställer 'iflag=fullblock' att 'count=' räknar kompletta indatablock snarare än ingångsläsoperationer. Som en förlängning till POSIX kopierar 'count=0' noll block istället för att kopiera alla block.
 
'''''<nowiki/>'status=nivå''''''
 
Ange mängden information som skrivs ut. Om denna operand ges flera gånger, har den sista företräde. Nivåvärdet kan vara något av följande:
 
'''''<nowiki/>'none''''''
 
Skriv inte ut några informations- eller varningsmeddelanden till standardfel. Felmeddelanden matas ut som vanligt.
 
'''''"noxfer"'''''
 
Skriv inte ut den slutliga överföringshastigheten och volymstatistiken som normalt utgör den sista statusraden.
 
'''''<nowiki/>'progress''''''
 
Skriv ut överföringshastighet och volymstatistik på standardfel vid bearbetning av varje inmatningsblock. Statistik matas ut på en enda rad högst en gång per sekund, men uppdateringar kan försenas när man väntar på I/O.
 
Överföringsinformation matas normalt ut till standardfel vid mottagande av "INFO"-signalen eller när dd avslutas, och är standard i följande form i C-lokalen:
 
 
<code>7287+1 records in</code>
 
<code>116608+0 records out</code>
 
<code>59703296 bytes (60 MB, 57 MiB) copied, 0.0427974 s, 1.4 GB/s</code>
 
 
Notationen 'w+p' står för w hela block och p partiella block. Ett partiellt block uppstår när en läs- eller skrivoperation lyckas men överför mindre data än blockstorleken. En ytterligare rad som "1 trunkerad post" eller "10 trunkerade poster" matas ut efter "records out"-raden om "conv=block" bearbetar trunkerade en eller flera indataposter.
 
'status='-operanden är en GNU-tillägg till POSIX.
 
'conv=omvandling[,omvandling]...'
 
Konvertera filen enligt specifikationen av konverteringsargumenten. (Inga mellanslag runt några kommatecken.)
 
Omvandlingar:
 
'ascii'
 
Konvertera EBCDIC till ASCII, med hjälp av konverteringstabellen specificerad av POSIX. Detta ger en 1:1-översättning för alla 256 byte. Detta innebär 'conv=unblock'; indata konverteras till ASCII innan efterföljande mellanslag tas bort.
 
"ebcdic"
 
Konvertera ASCII till EBCDIC. Detta är motsatsen till "ascii"-omvandlingen. Detta innebär 'conv=block'; efterföljande utrymmen läggs till innan de konverteras till EBCDIC.
 
'ibm'
 
Detta fungerar som 'conv=ebcdic', förutom att det använder den alternativa konverteringstabellen som anges av POSIX. Detta är inte en 1:1-översättning, utan återspeglar vanlig historisk praxis för '~', '[' och ']'.
 
Omvandlingarna 'ascii', 'ebcdic' och 'ibm' utesluter varandra. Om du använder någon av dessa omvandlingar bör du också använda operanden 'cbs='.
 
'blockera'
 
För varje rad i ingången, mata ut "cbs"-bytes, ersätt den nya ingångsraden med ett mellanslag och trunkering eller utfyllnad av ingångsrader med mellanslag vid behov.
 
"avblockera"
 
Ta bort eventuella efterföljande mellanslag i varje "cbs"-storlek inmatningsblock och lägg till en ny rad.
 
Omvandlingarna "blockera" och "avblockera" utesluter varandra. Om du använder någon av dessa konverteringar bör du också använda operanden 'cbs='.
 
"lcase"
 
Ändra stora bokstäver till gemener.
 
"ucase"
 
Ändra gemener till versaler.
 
Omvandlingarna "lcase" och "ucase" utesluter varandra.
 
'gles'
 
Försök att söka istället för att skriva NUL-utgångsblock. På ett filsystem som stöder glesa filer kommer detta att skapa gles utdata när utdatafilen utökas. Var försiktig när du använder den här konverteringen tillsammans med 'conv=notrunc' eller 'oflag=append'. Med 'conv=notrunc' kommer befintlig data i utdatafilen som motsvarar NUL-block från ingången att vara orörd. Med 'oflag=append' kommer de utförda sökningarna att vara ineffektiva. På liknande sätt, när utgången är en enhet snarare än en fil, kopieras inte NUL-ingångsblock, och därför är denna konvertering mest användbar med virtuella eller förnollställda enheter.
 
Den "glesa" konverteringen är en GNU-tillägg till POSIX.
 
'svabb'
 
Byt ut varje par indatabyte.
 
'synkronisera'
 
Paddla varje inmatningsblock till storleken "ibs" med efterföljande nollbyte. När det används med "blockera" eller "avblockera", fylla med mellanslag istället för noll byte.
 
Följande "konverteringar" är verkligen filflaggor och påverkar inte intern bearbetning:
 
"exkl"
 
Misslyckas om utdatafilen redan finns; dd måste skapa själva utdatafilen.
 
"nocreat"
 
Skapa inte utdatafilen; utdatafilen måste redan finnas.
 
Konverteringarna "excl" och "nocreat" är ömsesidigt uteslutande och är GNU-tillägg till POSIX.
 
'notrunc'
 
Trunkera inte utdatafilen.
 
'inget fel'
 
Fortsätt efter läsfel.
 
'fdatasync'
 
Synkronisera utdata precis innan avslutning, även om det fanns skrivfel. Detta tvingar fram en fysisk skrivning av utdata. Denna konvertering är en GNU-tillägg till POSIX.
 
"fsync"
 
Synkronisera utdata och metadata precis innan du avslutar, även om det fanns skrivfel. Detta tvingar fram en fysisk skrivning av utdata och metadata. Denna konvertering är en GNU-tillägg till POSIX.
 
'iflag=flagga[,flagga]...'
 
Få åtkomst till indatafilen med de flaggor som specificeras av flaggargumentet. (Inga mellanslag runt några kommatecken.)
 
'oflag=flagga[,flagga]...'
 
Få åtkomst till utdatafilen med de flaggor som anges av flaggargumentet. (Inga mellanslag runt några kommatecken.)
 
Här är flaggorna.
 
'bifoga'
 
Skriv i tilläggsläge, så att även om någon annan process skriver till den här filen, kommer varje dd-skrivning att läggas till det aktuella innehållet i filen. Denna flagga är bara meningsfull för utdata. Om du kombinerar denna flagga med operanden 'of=file', bör du också ange 'conv=notrunc' om du inte vill att utdatafilen ska trunkeras innan den läggs till.
 
"cio"
 
Använd samtidig I/O-läge för data. Detta läge utför direkt I/O och släpper POSIX-kravet för att serialisera alla I/O till samma fil. En fil kan inte öppnas i CIO-läge och med en standard öppen samtidigt.
 
'direkt'
 
Använd direkt I/O för data, undvik buffertcachen. Observera att kärnan kan införa begränsningar för läs- eller skrivbuffertstorlekar. Till exempel, med ett ext4-destinationsfilsystem och en Linux-baserad kärna, kommer användning av 'oflag=direct' att göra att skrivning misslyckas med EINVAL om utdatabuffertens storlek inte är en multipel av 512.
 
"katalog"
 
Misslyckas om inte filen är en katalog. De flesta operativsystem tillåter inte I/O till en katalog, så denna flagga har begränsad nytta.
 
"dsync"
 
Använd synkroniserad I/O för data. För utdatafilen tvingar detta fram en fysisk skrivning av utdata vid varje skrivning. För indatafilen kan denna flagga ha betydelse vid läsning från en fjärrfil som har skrivits till synkront av någon annan process. Metadata (t.ex. senaste åtkomst och senast ändrade tid) synkroniseras inte nödvändigtvis.
 
'synkronisera'
 
Använd synkroniserad I/O för både data och metadata.
 
"nocache"
 
Begär att kassera systemdatacachen för en fil. När count=0 specificeras all cachad data för filen, annars släpps cachen för den bearbetade delen av filen. Också när count=0, diagnostiseras misslyckandet med att kassera cachen och återspeglas i utgångsstatusen.
 
Notera data som inte redan finns kvar till lagring kommer inte att kasseras från cachen, så notera användningen av "synkroniserings"-konverteringarna i exemplen nedan, som används för att maximera effektiviteten av "nocache"-flaggan.
 
Här är några användningsexempel:
 
<code># Advise to drop cache for whole file</code>
 
<code>dd if=ifile iflag=nocache count=0</code>
 
 
<code># Ensure drop cache for the whole file</code>
 
<code>dd of=ofile oflag=nocache conv=notrunc,fdatasync count=0</code>
 
 
<code># Advise to drop cache for part of file
<nowiki>#</nowiki> Note the kernel will only consider complete and
<nowiki>#</nowiki> already persisted pages.</code>
 
<code>dd if=ifile iflag=nocache skip=10 count=10 of=/dev/null</code>
 
 
<code># Stream data using just the read-ahead cache.</code>
 
<code># See also the ‘<samp>direct</samp>’ flag.</code>
 
<code>dd if=ifile of=ofile iflag=nocache oflag=nocache,sync</code>
 
 
"nonblock"
 
Använd icke-blockerande I/O.
 
"noatime"
 
Uppdatera inte filens åtkomsttidsstämpel. Se Fil tidsstämplar. Vissa äldre filsystem ignorerar denna flagga tyst, så det är en bra idé att testa den på dina filer innan du litar på den.
 
"noggig"
 
Tilldela inte filen att vara en kontrollerande terminal för dd. Detta har ingen effekt när filen inte är en terminal. På många värdar (t.ex. GNU/Linux-värdar) har denna flagga ingen effekt alls.
 
"nofollow"
 
Följ inte symboliska länkar.
 
"nolinks"
 
Misslyckas om filen har flera hårda länkar.
 
'binär'
 
Använd binär I/O. Denna flagga har endast effekt på icke-standardiserade plattformar som skiljer binär från text I/O.
 
'text'
 
Använd text I/O. Liksom "binär" har denna flagga ingen effekt på standardplattformar.
 
"fullblock"
 
Ackumulera hela block från input. Det lästa systemanropet kan återkomma tidigt om ett helt block inte är tillgängligt. När det händer fortsätter du att anropa read för att fylla resten av blocket. Denna flagga kan endast användas med iflag. Den här flaggan är användbar med till exempel rör eftersom de kan returnera korta läsningar. I så fall behövs denna flagga för att säkerställa att ett "count="-argument tolkas som ett blockantal snarare än ett antal läsoperationer.
 
Dessa flaggor är alla GNU-tillägg till POSIX. De stöds inte på alla system, och "dd" avvisar försök att använda dem när de inte stöds. När du läser från standardinmatning eller skrivning till standardutdata bör inte 'nofollow' och 'noctty'-flaggorna specificeras, och de andra flaggorna (t.ex. 'nonblock') kan påverka hur andra processer beter sig med de påverkade filbeskrivningarna, även efter dd går ut.
 
Beteendet för dd är ospecificerat om andra operander än 'conv=', 'iflag=', 'oflag=' och 'status=' anges mer än en gång.
 
De numeriskt värderade strängarna ovan (n och byte) är decimala heltal utan tecken som kan följas av en multiplikator: 'b'=512, 'c'=1, 'w'=2, 'xm'=m eller någon av standardblockstorlekssuffixen som 'k'=1024 (se Blockstorlek). Dessa multiplikatorer är GNU-tillägg till POSIX, förutom att POSIX tillåter bytes att följas av 'k', 'b' och 'xm'. Blockstorlekar (dvs. specificerade av bytesträngar) måste vara lik noll.
 
Alla blockstorlekar du anger via 'bs=', 'ibs=', 'obs=', 'cbs=' bör inte vara för stora – värden större än några megabyte är i allmänhet slösaktiga eller (som i fallet gigabyte..exabyte) ) direkt kontraproduktivt eller felframkallande.
 
För att bearbeta data med offset eller storlek som inte är en multipel av I/O-blockstorleken kan du använda en numerisk sträng n som slutar på bokstaven 'B'. Följande skalkommandon kopierar till exempel data i 1 MiB-block mellan en flashenhet och ett band, men sparar eller återställer inte ett 512-bytesområde i början av flashenheten:
 
flash=/dev/sda
 
tape=/dev/st0
 
 
<code># Kopiera alla utom de första 512 byten från flash till band.</code>
 
<code>dd if=$flash iseek=512B bs=1MiB of=$tape</code>
 
 
<code># Kopiera från bandet tillbaka till flash, lämna initiala 512 byte ensamma.</code>
 
<code>dd if=$tape bs=1MiB of=$flash oseek=512B</code>
 
För felande lagringsenheter kommer andra verktyg med en stor mängd extrafunktioner för att underlätta lagringen av så mycket data som möjligt innan enheten slutligen dör, t.ex. GNU ddrescue. Men i vissa fall är ett sådant verktyg inte tillgängligt eller så känner sig administratören mer bekväm med hanteringen av dd. Som en enkel räddningsmetod, anrop dd som visas i följande exempel: operanden 'conv=noerror,sync' används för att fortsätta efter läsfel och för att fylla ut dåliga läsningar med NUL, medan 'iflag=fullblock' tar hand om korta läsningar (som traditionellt aldrig förekommer på blixt eller liknande enheter):
 
<code># Rescue data from an (unmounted!) partition of a failing device.
dd conv=noerror,sync iflag=fullblock </dev/sda1 > /mnt/rescue.img</code>
 
Att skicka en 'INFO'-signal (eller 'USR1'-signal där den inte är tillgänglig) till en pågående dd-process gör att den skriver ut I/O-statistik till standardfel och återupptar sedan kopieringen. I exemplet nedan körs dd i bakgrunden för att kopiera 5 GB data. Kill-kommandot gör att den matar ut mellanliggande I/O-statistik, och när dd slutförs normalt eller dödas av SIGINT-signalen, matar den ut den slutliga statistiken.
 
<code># Ignore the signal so we never inadvertently terminate the dd child.</code>
 
<code># Note this is not needed when SIGINFO is available.</code>
 
<code>trap <nowiki>''</nowiki> USR1</code>
 
 
<code># Run dd with the fullblock iflag to avoid short reads</code>
 
<code># which can be triggered by reception of signals.</code>
 
<code>dd iflag=fullblock if=/dev/zero of=/dev/null count=5000000 bs=1000 & pid=$!</code>
 
<code># Output stats every second.</code>
 
<code>while kill -s USR1 $pid 2>/dev/null; do sleep 1; done</code>
 
Ovanstående skript kommer att matas ut i följande format:
 
<code>3441325+0 records in</code>
 
<code>3441325+0 records out</code>
 
<code>3441325000 bytes (3.4 GB, 3.2 GiB) copied, 1.00036 s, 3.4 GB/s</code>
 
<code>5000000+0 records in</code>
 
<code>5000000+0 records out
5000000000 bytes (5.0 GB, 4.7 GiB) copied, 1.44433 s, 3.5 GB/s</code>
 
"status=framsteg"-operanden uppdaterar med jämna mellanrum den sista raden i överföringsstatistiken ovan.
 
På system som saknar 'INFO'-signalen svarar dd på 'USR1'-signalen istället, om inte miljövariabeln POSIXLY_CORRECT är inställd.
 
En utgångsstatus på noll indikerar framgång och ett värde som inte är noll indikerar misslyckande.
 
Denna sida är översättning ifrån
 
[https://www.gnu.org/software/coreutils/manual/html_node/dd-invocation.html#dd-invocation 11.2 <code>dd</code>: Convert and copy a file]

Nuvarande version från 28 maj 2024 kl. 08.46

Omdirigering till:

Hämtad från "https://wiki.linux.se/index.php?title=Fullbeskrivning_av_dd&oldid=2212"