Klonujte oddíl Windows z Linuxu

Budete muset naklonovat 2 oddíly pomocí dd - jeden je místo, kde se nachází bootloader/bootmanager (potřebný k řetězovému načtení operačního systému) [System Reserved , obvykle 100M] a druhý je skutečná instalace W7.

Zkontrolujte tabulku oddílů pomocí cfdisk - poskytne vám vizuální reprezentaci. Poté odstraňte všechny oddíly na cílovém disku - cfdisk je váš přítel.

Syntaxi pro klonování lze nalézt na wiki zde. Budete také potřebovat správný MBR (pravděpodobně se již nachází na vaší testovací jízdě ).

Pravděpodobně budete muset přiřadit zaváděcí příznak také do oddílu [System Reserved] (to by měl být první klonovaný) - cfdisk může toho dosáhnout.

Pokud to selže, jednoduše zaveďte systém z instalačního disku W7 a postupujte podle pokynů pro systém Vista.

AKTUALIZACE :

Zapomněl jsem zmínit jednu důležitou část celého procesu, která nemusí být tak evidentní. Buď budete muset naklonovat tabulku oddílů z původního disku a smazat vše kromě 2 oddílů souvisejících s Windows, NEBO je znovu vytvořit pomocí cfdisk / rozešli se stejným velikost.

Zde je několik příkladů (za předpokladu, že sda je váš zdrojový disk a sdb je cíl):

dd if=/dev/sda bs=1 skip=446 count=66 of=/dev/sdb seek=446 (to účinně naklonuje vaši aktuální tabulku oddílů DOS spolu s podpisem MBR na výstupní jednotku)

dd if=/dev/sda bs=1 skip=440 count=72 of=/dev/sdb seek=440 (také se zkopíruje ID disku, což může někdy vést k selhání spouštění, pokud chybí – takové disky však nebudou moci spolupracovat v prostředí Windows, dokud se ID nezmění)

parted /dev/sda u s p (takto můžete zkontrolovat aktuální tabulku oddílů a velikost v sektorech na zdrojovém disku pro pozdější replikaci na cíli pomocí buď cfdisk nebo rozdělené sám)

Podívejte se na

• ntfsclone (kopíruje pouze používané sektory)
• fixntfs.c k opravě odchylek spouštěcích informací

IIRC, Trinity Rescue Kit obsahuje potřebný software a také mnoho dalších (ssh, partimage, fdisk, fdisk, cfdisk, parted, gparted, testdisk, ntfsfix; montáž ntfs-3g, rsync atd. atd.).

/*
 * fixntfs: change some attributes of an NTFS bootsector
 *
 * brought to you by Phoenix
 * url: www.grhack.gr/phoenix
 * mail: [email protected]
 * irc: phoenix -> #grhack -> undernet
 */

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
    FILE *fd;
    FILE *idfd;
    struct stat fst;
    unsigned char cab[32];
    unsigned short log_heads;
    unsigned short ntfs_heads;
    unsigned short force_heads;
    unsigned short ntfs_cab;
    unsigned long long sectors;
    unsigned long long new_sectors;

    log_heads = 0;
    ntfs_heads = 0;
    force_heads = 0;
    ntfs_cab = 0;

    if(argc < 2)
    {
        fprintf(stderr, "Usage:\n\t%s <device> <total_sectors> <force_heads>\n", argv[0]);
        exit(0);
    }

    fprintf(stderr, "Stating file %s... ", argv[1]);

    stat(argv[1], &fst);

    if(!S_ISBLK(fst.st_mode))
    {
        fprintf(stderr, "not a block device\n");
        exit(-1);
    }

    fprintf(stderr, "a block device\n");


    fprintf(stderr, "Opening device %s rw... ", argv[1]);

    fd = fopen(argv[1], "r+");

    if(!fd)
    {
        perror("open device");
        exit(-1);
    }

    fprintf(stderr, "ok\n");


    fprintf(stderr, "Checking partition... ");

    fseek(fd, 3, SEEK_SET);

    if(fread(cab, 1, 4, fd) != 4)
    {
        perror("read system_id");
        exit(-1);
    }

    cab[5] = 0;

    if(strncmp(cab, "NTFS", 4))
    {
        fprintf(stderr, "%s\n", cab);
        exit(-1);
    }

    fprintf(stderr, "%s\n", cab);


    fprintf(stderr, "Reading NTFS bootsector heads... ");

    fseek(fd, 0x1a, SEEK_SET);

    ntfs_heads = 0;

    fread(&ntfs_heads, 1, 2, fd);

    fprintf(stderr, "%u\n", ntfs_heads);


    fprintf(stderr, "Reading NTFS bootsector sectors... ");

    fseek(fd, 0x18, SEEK_SET);

    ntfs_cab = 0;

    fread(&ntfs_cab, 1, 2, fd);

    fprintf(stderr, "%u\n", ntfs_cab);


    fprintf(stderr, "Reading NTFS bootsector sectors_per_cluster... ");

    fseek(fd, 0x0d, SEEK_SET);

    ntfs_cab = 0;

    fread(&ntfs_cab, 1, 1, fd);

    fprintf(stderr, "%u\n", ntfs_cab);


    fprintf(stderr, "Reading NTFS bootsector sectors_size... ");

    fseek(fd, 0x0b, SEEK_SET);

    ntfs_cab = 0;

    fread(&ntfs_cab, 1, 2, fd);

    fprintf(stderr, "%u\n", ntfs_cab);


    fprintf(stderr, "Reading NTFS bootsector boot_loader_routine_jump... ");

    fseek(fd, 0, SEEK_SET);

    bzero(cab, sizeof(cab));

    fread(cab, 1, 3, fd);

    fprintf(stderr, "0x%x 0x%x 0x%x\n", cab[0], cab[1], cab[2]);

    fprintf(stderr, "Reading NTFS bootsector total_sectors... ");

    fseek(fd, 0x28, SEEK_SET);

    sectors = 0;

    fread(&sectors, 1, 8, fd);

    fprintf(stderr, "%Lu\n", sectors);


    fprintf(stderr, "Reading device logical heads... ");

    sprintf(cab, "/proc/ide/hd%c/geometry", *(strrchr(argv[1],'/') + 3));

    idfd = fopen(cab, "r");

    if(!idfd)
    {
        perror(cab);
        exit(-1);
    }

    fscanf(idfd, "%*s %*s\n");

    fscanf(idfd, "%*s %s\n", cab);

    *(strrchr(cab, '/')) = 0;

    log_heads = (unsigned short) atoi(strchr(cab, '/') + 1);

    fprintf(stderr, "%u\n", log_heads);

    if(argc == 4)
    {
        force_heads=atoi(argv[3]);
        fprintf(stderr, "Forcing heads to %u\n", force_heads);
        log_heads=force_heads;
    }

    if(fclose(fd) == EOF)
    {
        perror("close device");
        exit(-1);
    }

    if(log_heads != ntfs_heads)
    {
        fprintf(stderr, "Heads are different... Logical=%u NTFS=%u\n\n"
                "Update NTFS bootsector? (y/n) ",
                log_heads, ntfs_heads);

        if(getc(stdin) == 'y')
        {
            fd = fopen(argv[1], "r+");

            if(!fd)
            {
                perror("open device");
                exit(-1);
            }

            ntfs_heads = log_heads;

            fseek(fd, 0x1a, SEEK_SET);

            fwrite(&ntfs_heads, 1, 2, fd);


            fprintf(stderr, "\nBootsector updated... Verifying... ");

            fclose(fd);

            fd = fopen(argv[1], "r");

            if(!fd)
            {
                perror("open device");
                exit(-1);
            }

            fseek(fd, 0x1a, SEEK_SET);

            ntfs_heads = 0;

            fread(&ntfs_heads, 1, 2, fd);

            if(ntfs_heads == log_heads)
            {
                fprintf(stderr, "ok\n\n");
            }
            else
            {
                fprintf(stderr, "error [%u]\n", ntfs_heads);
                exit(-1);
            }
            fclose(fd);
        }
        else
        {
            fprintf(stderr, "\nHeads update cancelled...\n");
        }

        getc(stdin);
    }

    if(argc >= 3 && atoll(argv[2]))
    {
        fprintf(stderr, "Update NTFS bootsector total_sectors from %Lu to %Lu? (y/n) ",
                sectors, atoll(argv[2]));

        if(getc(stdin) == 'y')
        {
            fd = fopen(argv[1], "r+");

            if(!fd)
            {
                perror("open device");
                exit(-1);
            }

            new_sectors = atoll(argv[2]);

            fseek(fd, 0x28, SEEK_SET);

            fwrite(&new_sectors, 1, 8, fd);


            fprintf(stderr, "\nBootsector updated... Verifying... ");

            fclose(fd);

            fd = fopen(argv[1], "r");

            if(!fd)
            {
                perror("open device");
                exit(-1);
            }

            fseek(fd, 0x28, SEEK_SET);

            sectors = 0;

            fread(&sectors, 1, 8, fd);

            if(sectors == new_sectors)
            {
                fprintf(stderr, "ok\n\n");
            }
            else
            {
                fprintf(stderr, "error [%Lu]\n", sectors);
                exit(-1);
            }

            fclose(fd);
        }
        else
        {
            fprintf(stderr, "\nTotal_sectors update cancelled...\n");
        }
        getc(stdin);
    }

    return(1);
}

Tento návod na klonování jednotky Windows pro mě fungoval skvěle. Protože je to poprvé, co se mi podařilo přenést instalaci systému Windows na nový pevný disk, podělím se zde o svůj postup, abych pomohl dalšímu zaměstnanci společnosti Google, kterého navštíví.

Moje situace:
Manažerský Windows 7 x64 měl maximální kapacitu 128G SSD, takže jsem koupil náhradní 240 GB.

Problém:
Mám dva doky SATA disků, ale linux nerozpoznal oba současně, což znemožňuje snadné kopírování mezi nimi.

Hardware:
Chystám se nastavit duální NIC firewall, takže jsem nainstaloval zdrojový SSD do tohoto počítače. Cílový 240G SSD šel do externího doku.

Proces:
1) První USB klíčenka, kterou jsem vzal, měla živé CD Linux Mint, které se stalo /dev/sda1
2) „Starý“ 128G SSD byl detekován a stal se /dev/sdb1 a /dev/sdb2
3) Použito # fdisk -l /dev/sdb z výukového programu a zkopírovali informace o okně zdrojového oddílu do Gedit.
- Všimněte si, že výukový program obsahuje -u volba, nicméně pro mě fdisk již zobrazoval bloky (požadovaný výstup), takže zahrnutí tohoto přepínače poskytuje špatné informace.
4) Zapojte a zapněte dokovací stanici s cílovým 240G SSD, což se změní na /dev/sdc .
5) Použijte fdisk /dev/sdc vytvořit oddíly na /dev/sdc které přesně odpovídají /dev/sdb , včetně spouštěcích a systémových příznaků.
6) dd if=/dev/sdb of=/dev/sda bs=446 count=1 pro zkopírování MBR na cílovou jednotku.
-- Průvodce nyní doporučuje použít hdparm zapnout DMA, ale příkaz se mi nezdařil
7) ntfsclone -O /dev/sdc1 /dev/sdb1 zkopírujte skrytý systémový oddíl systému Windows.
-- -O nebo --overwrite volba se používá k nastavení cíle, takže příkaz se zobrazí pozpátku. Sláva Linux Mint live CD s ntfsclone, protože jsem o tomto příkazu předtím neslyšel a nemusel jsem se dostat do sítě.
8) Použijte ntfsclone -O /dev/sdc2 /dev/sdb2 zkopírujte Windows "C Drive". K dokončení bylo potřeba pár piv.
9) Pro změnu velikosti oddílu jsem použil gparted
10) Znovu nainstaloval nový SSD do počítače se systémem Windows a spustí checkdisk (opustil jsem tutoriál a nevšiml jsem si, že to dělá).
11) Restartoval Windows a vše se vrátilo do normálu, ale s více volným místem.