Dd තවමත් වැඩ කරන්නේ දැයි මා දැන ගන්නේ කෙසේද?

මම එතරම් භාවිතා කර නැත dd, නමුත් මෙතෙක් එය මා අසමත් වී නැත. මේ ddමොහොතේ, මට පැය 12 කට වඩා වැඩි කාලයක් ගතවී ඇත - මම එය නැවත තැටියට ලියමි - මම ddතැටියේ සිට රූපය දක්වා ගත හැකි වූ නිසා මම ටිකක් කනස්සල්ලට පත්ව සිටිමි. පැය 7 යි.

මම OSB 10.6.6 මැක්බුක් එකක Core 2 Duo සමඟ 2.1ghz / core 4gb RAM සමඟ ධාවනය කරමි. මම .dmg සිට 7200rpm දෘ drive තැටියක (ඇරඹුම් ධාවකය) කියවන අතර, මම SATA-to-USB සම්බන්ධකයක් හරහා සම්බන්ධ කර ඇති 7200rpm ධාවකය වෙත ලියමි. මම පෙරනිමියෙන් බ්ලොක්සයිස් අතහැර ගිය අතර රූපය 160gb පමණ වේ.

සංස්කරණය කරන්න: තවද, පැය 14 ක පිරිසිදු ආතතියෙන් පසුව, ddවැඩ කිරීමෙන් පසු සියල්ල හොඳින් ක්‍රියාත්මක විය. ඊළඟ වතාවේ, නමුත්, මම හරහා ක්රියාත්මක කිරීමට යන්නේ pvසහ එය නිරීක්ෂණය strace. ඔබගේ සියලු උදව් සඳහා සැමට ස්තූතියි.

විධානය ddභාවිතා කර යම් සං signal ාවක් යැවිය killහැකි අතර එය එහි වත්මන් තත්වය ප්‍රතිදානය කරයි. සං signal INFOාව BSD පද්ධතිවල (OSX ඇතුළුව) සහ USR1ලිනක්ස් වල ඇත. ඔබේ නඩුවේ:

kill -INFO $PID

ඔබට විධානය $PIDසමඟ ක්‍රියාවලි හැඳුනුම්පත ( ඉහළ) සොයාගත හැකිය ps; හෝ වඩාත් පහසු ක්‍රම සඳහා මැක් os x හි pgrep සහ pkill විකල්ප බලන්න .

වඩාත් සරළව කිවහොත්, ඇන්ටොයින් ජී ඔහුගේ පිළිතුරෙන් පෙන්වා දෙන පරිදි , ඔබට සං d ාවctrl-T යැවීම සඳහා ෂෙල් ධාවනය වන ඩීඩී ටයිප් කළ හැකිය INFO.

ලිනක්ස් හි උදාහරණයක් ලෙස, ඔබට සියලු ක්‍රියාකාරී ddක්‍රියාවලීන්ගේ ප්‍රතිදාන තත්ත්වය මේ ආකාරයෙන් කළ හැකිය:

pkill -USR1 -x dd

එහි තත්වය ප්‍රතිදානය කිරීමෙන් පසුව, ddඑය දිගටම කරගෙන යනු ඇත.

OS X යටතේ (ලිනක්ස් මත උත්සාහ කළේ නැත), ඔබට ටර්මිනල් ධාවනයේ Ctrl+ ටයිප් කළ හැකිය . එය CPU භාවිතය හා සමාන ප්‍රතිදානය මුද්‍රණය කරයි :Tddkill -INFO $PID

load: 1.40  cmd: dd 34536 uninterruptible 3.49u 64.58s
5020305+0 records in
5020304+0 records out
2570395648 bytes transferred in 4284.349974 secs (599950 bytes/sec)

මම මේ ත්‍රෙඩ් එක කියවා මගේ ටර්මිනලයේ නව ටැබ් එකක් විවෘත කිරීමට උත්සාහ කළ නමුත් ⌘+ Tසමඟ Ctrl+ මිශ්‍ර කරමි T.

සඳහා dd, ඔබට සං .ාවක් යැවිය හැකිය . ගොනුවක් කියවන හෝ ලියන වෙනත් විධානයන් සඳහා, ඔබට ගොනුවේ ඒවායේ පිහිටීම නැරඹිය හැකිය lsof.

lsof -o -p1234    # where 1234 is the process ID of the command
lsof -o /path/to/file

ඔබ කල්තියා සැලසුම් කරන්නේ නම්, දත්ත හරහා නල කරන්න pv.

වඩාත් පොදු ක්‍රමයක් නම්, iotopඑක් වැඩසටහනකට දැනට පවතින තැටි කියවීම / ලිවීම පෙන්වන ප්‍රමාණය භාවිතා කිරීමයි .

සංස්කරණය කරන්න: iotop -oදැනට I / O මෙහෙයුම් සිදුකරන වැඩසටහන් පමණක් පෙන්වන්න ( මෙම අදහස් දැක්වීමට ස්තූතියි ජේසන් සී ).

මම සාමාන්‍යයෙන් straceඑවැනි ක්‍රියාකාරී ක්‍රියාවලියකට ( -p $PIDවිකල්පය සමඟ ) සම්බන්ධ වන්නේ එය පද්ධති ඇමතුමක අවහිර වී ඇත්දැයි හෝ එය තවමත් ක්‍රියාකාරීද යන්නයි.

නැතහොත්, ධාවනය වන ඩීඩී වෙත සං signal ාවක් යැවීම ගැන ඔබට බියක් දැනේ නම්, මෙය ක්‍රියාත්මක වන්නේ නම් වලංගු කිරීම සඳහා තවත් ඩීඩී එකක් ආරම්භ කරන්න.

ඊළඟ වතාවට, ඔබට pvමුල සිටම භාවිතා කළ හැකිය (එය ඔබේ පැකේජ කළමනාකරු හරහා තිබේ නම්, එය ස්ථාපනය කරන්න). මෙය නිමැවුම් සඳහා නල මාර්ගගත කිරීම සහ ප්‍රගතිය සහ වේගය අධීක්ෂණය කිරීමේ එකම අරමුණ ඇති උපයෝගීතාවයකි.

ඉන්පසු, ඩ්‍රයිව් එකකට රූපයක් ලිවීම සඳහා, 4MB බ්ලොක් ප්‍රමාණයෙන් කියන්න:

pv -ptearb /path/to/image.bin | dd iflag=fullblock of=/dev/whatever bs=4M

ආරම්භක බෆරයට අමතරව ( ddඔබට අවශ්‍ය නම් එය කළ හැකි අවසාන සමමුහුර්තකරණයකින් ඕෆ්සෙට් කරන්න), මෙය ඔබට ප්‍රගති තීරුවක්, සාමාන්‍ය වේගය, වත්මන් වේගය සහ ETA පෙන්වයි.

මෙම iflag=fullblockවිකල්පය හමුදා මගින් ආදාන පූර්ණ කුට්ටි උදුරා ගන්න dd pvවෙනත් ආකාරයකින් ඔබට වාරණ ප්රමාණ සඳහා නල අනුකම්පාව ඉන්නේ,.

අනෙක් පැත්තට යාමට කියවීමට dd සහ ලිවීමට pv භාවිතා කරන්න, නමුත් ප්‍රභවය අවහිර උපාංගයක් නම් ඔබට ප්‍රමාණය පැහැදිලිවම සඳහන් කළ යුතුය. 4GB උපාංගයක් සඳහා:

dd if=/dev/whatever bs=4M | pv -ptearb -s 4096m > /path/to/image.bin

ඔබට ප්‍රමාණය ස්වයංක්‍රීයව තීරණය කළ හැකිය, වැනි දෙයක්:

dd if=/dev/whatever bs=4M | pv -ptearb -s `blockdev --getsize64 /dev/whatever` > /path/to/image.bin

ඇත්තෙන්ම එය ඔබ ඇණවුම් දේ ප්රශ්නයක් නොවේ ddහා pvඔබ හෝ කියවන උපකරණය භාවිතා කිරීමට අවශ්ය යම් යම් blocksizes සඳහා ප්රශස්ත කාර්ය සාධනය ඇත්තේ නම් - එය සම්පූර්ණයෙන්ම කාර්ය සාධන සම්බන්ධ වේ ddවෙනුවට pvඋපාංගය සඳහා ප්රවේශ. ඔබ පවා මිනිසුන්ට පුළුවන් ddඔබ ගණන් ගන්නේ නැහැ නම් සියලු දී ඔබට අවශ්ය නම් දෙපසම මත, හෝ නොවේ:

pv -ptearb /path/to/image.bin > /dev/whatever
sync

වන විට coreutilsv8.24, ddප්රගතිය දැක්වෙන සදහා එකවරම සහය දක්වන ඇත. විකල්පය එක් කරන්න status=progress.

උදාහරණයක්:

dd if=arch.iso of=/dev/sdb bs=4M status=progress

මූලාශ්රය

ddrescue එය ක්‍රියාත්මක වන විට ඔබට සංඛ්‍යාලේඛන ලබා දෙනු ඇත.

නිරූපණය: http://www.youtube.com/watch?v=vqq9A01geeA#t=144s

සමහර විට ඔබට INFO හෝ USR1 සං signal ාව භාවිතා කිරීමට නොහැකි වනු ඇත, මන්ද ddක්‍රියාවලියේ stderr ප්‍රවාහයට ප්‍රවේශ විය නොහැකි බැවිනි (උදා: එය ක්‍රියාත්මක කළ පර්යන්තය දැනටමත් වසා ඇති නිසා). මෙම අවස්ථාවෙහිදී, පහත දැක්වෙන දේ කිරීම (ෆ්‍රීබීඑස්ඩී හි පරීක්ෂා කර ඇත, ලිනක්ස් මත තරමක් වෙනස් විය හැකිය):

1. iostatඉලක්කගත උපාංගයට සාමාන්‍ය ලිවීමේ අනුපාතය (MB / s) තක්සේරු කිරීමට භාවිතා කරන්න , උදා:

   iostat -d -w30 ada0

   ඔබගේ ඉලක්ක උපාංගයේ නම ada0මෙහි ආදේශ කරන්න, ප්‍රති .ල කිහිපයක් ලබා දීමට විනාඩියක් ඉන්න. "W" පරාමිතිය සාම්පල අතර තත්පර කීයක් තීරණය කරයි. එය වැඩි කිරීමෙන් අඩු විචල්‍යතාවයකින් වඩා හොඳ සාමාන්‍ය ඇස්තමේන්තුවක් ලැබෙනු ඇත, නමුත් ඔබට වැඩි කාලයක් බලා සිටීමට සිදුවනු ඇත.

2. psකොපමණ කාලයක් ddධාවනය වී ඇත්දැයි තීරණය කිරීමට භාවිතා කරන්න :

   ps -xo etime,command | grep dd

   ධාවන කාලය තත්පර ලබා ගැනීම සඳහා මෙය තත්පරයට පරිවර්තනය කරන්න.

3. සම්පුර්ණ මාරු කළ MB ලබා ගැනීම සඳහා ධාවන කාලය තත්පර ගණන සාමාන්‍ය ලිවීමේ අනුපාතය අනුව ගුණ කරන්න.

4. උපාංගයේ ප්‍රමාණය MB වලින් ලබා ගන්න:

   grep ada0 /var/run/dmesg.boot

   ඔබගේ ඉලක්ක උපාංගයේ නම ආදේශ කරන්න ada0. සම්පූර්ණ හුවමාරු කාලය තත්පර කිහිපයකින් ලබා ගැනීම සඳහා සාමාන්‍ය ලිවීමේ අනුපාතය අනුව ප්‍රති result ලය බෙදන්න. කාලය ඉතිරි කර ගැනීම සඳහා මෙතෙක් ක්‍රියාත්මක වූ කාලය අඩු කරන්න.

මෙම උපායමාර්ගය ක්‍රියාත්මක වන්නේ ddඑය ආරම්භයේ සිට වර්තමාන සාමාන්‍ය ලිවීමේ අනුපාතයට අඛණ්ඩව ලිවීමෙන් පමණි . CPU හෝ I / O සම්පත් සඳහා (I / O බස් රථය ඇතුළුව) වෙනත් ක්‍රියාදාමයන් තරඟ කරන්නේ නම් එය හුවමාරු අනුපාතය අඩු කළ හැකිය.

මම dcfldd (1) භාවිතා කිරීමට පටන් ගත්තෙමි, එය dd මෙහෙයුම් වඩා හොඳ ආකාරයකින් පෙන්වයි.

progressවිශේෂයෙන් ධාවනයක ප්‍රගතිය පෙන්වන ඔබට එය භාවිතා කළ හැකිය dd. එය භාවිතා කරයි /proc/$pid/fdසහ /proc/$pid/fdinfo ඔබ ද අතින් අධීක්ෂණය කල හැක.

ddක්‍රියාත්මක කරන අතරතුර , මම මෙය වෙනත් පර්යන්තයක root ලෙස ධාවනය කරමි:

while pgrep ^dd; do pkill -INFO dd; sleep 1; done

එය මුද්රණය ddසෑම තත්පර 1 තත්වය මුල් පර්යන්තය කවුළුව තුළ එහිදී ddක්රියාත්මක කර තිබේ නම්, එම විධානය කළ විට ඉනිම නිමා කරයි.

මෙම wcharරේඛාව (ලිඛිත අක්ෂර) හි /proc/$pid/ioඔබ මේ ගැන නිවැරදි තොරතුරු ලබා දිය හැක ddක්රියාවලිය. එය වෙනස් වන තාක් කල්, ඔබ ddතවමත් ක්‍රියා කරයි!

මෙහිදී ඔබට සුරැකීමට සහ පසුව සමග ක්රියාත්මක කළ හැකි ක්රමවත් ටිකක් php තිර රචනය, වන php filename.phpකාලය තුළ ddලිඛිත බයිට් ප්රදර්ශනය කිරීමට. බලා යන ලස්සන ප්රතිලාභ /proc/$pid/ioවැඩි kill -USR1 $(pidof dd)ඔබ හැම විටම විකල්පයක් නොවන පර්යන්ත, අතර මාරු වීම සඳහා නොමැති බව ය.

<?php

/** Time between refreshs in seconds */
$refresh = 1;


/**
 * Start of Script 
 */

if (!($pid = exec('pidof dd')))
    exit("no dd running\n");

$history = array();
$break_ms = $refresh * 1000000;
$start_time = exec("ls -ld /proc/$pid --time-style=+\"%s\" | egrep -o [0-9]{10}");


fprintf(STDOUT, "PID: %s\n", $pid);
fprintf(STDOUT, "START TIME: %s\n\n", date("Y-m-d H:i:s", $start_time));


while (true) {
    if (isset($curr))
        array_push($history, $curr);

    if (count($history) > 10) array_shift($history);
    $oldest = reset($history);
    $latest = end($history);

    /**
     * get number of written bytes from /proc/$pid/io
     */
    #if (!($curr = exec("cat /proc/$pid/io | grep ^write_bytes | sed 's/write_bytes: //g'")))
    #    break;

    /* prepare proc_open() parameter */
    $descriptorspec = array(
        0 => array('pipe', 'r'), // stdin
        1 => array('pipe', 'w'), // stdout
        2 => array('pipe', 'w'), // stderr
    );

    $process = proc_open("cat /proc/$pid/io | grep ^write_bytes | sed 's/write_bytes: //g'", $descriptorspec, $pipes);
    if (!is_resource($process)) break;

    $stdout = stream_get_contents($pipes[1]);
    $stderr = stream_get_contents($pipes[2]);
    proc_close($process);

    if (!empty($stderr)) break;
    $curr = trim($stdout);

    /**
     * caculate elapsed time from start */
    $time_elapsed = time() - $start_time;

    /**
     * avg speed since start */
    $avg = $time_elapsed > 0 ? round($curr / $time_elapsed) : 0;

    /**
     * avg speed of last 10 updates */
    if (count($history) > 0)
        $speed = human_file_size(round(($latest - $oldest) / count($history) / $refresh));

    $output = sprintf("\rBYTES WRITTEN: %s [%s]  ::  CURRENT: %s/s  ::  AVERAGE: %s/s  ::  ELAPSED: %s", $curr, human_file_size($curr), isset($speed) ? $speed : 0, human_file_size($avg), gmdate("H:i:s", $time_elapsed));
    printf("%s%s", $output, str_repeat(" ", exec("tput cols") - strlen($output)));

    usleep($break_ms);
}

fprintf(STDOUT, "\ndd has finished!\n\n");

function human_file_size($size,$unit="") {
  if( (!$unit && $size >= 1<<30) || $unit == "GB")
    return number_format($size/(1<<30),2)." GB";
  if( (!$unit && $size >= 1<<20) || $unit == "MB")
    return number_format($size/(1<<20),2)." MB";
  if( (!$unit && $size >= 1<<10) || $unit == "kB")
    return number_format($size/(1<<10),2)." kB";
  return number_format($size)." bytes";
}