Klonuj partycję Windows z Linuksa

Mam więc dysk SSD Intel 120 GB z partycją dla Windows i kolejną dla Ubuntu. Ubuntu to mój główny system operacyjny, Windows to gra. Ale teraz chcę zainstalować Mac OS X i chciałbym, żeby był na dysku SSD, więc chcę przenieść system Windows na inny dysk (stary zewnętrzny dysk 160 GB, który wyjąłem z jego powłoki i zostałem używam jako dysku testowego. I tak trzymam swoje gry na innym komputerze zewnętrznym, więc nie powinno to wpływać na wydajność, poza czasem uruchamiania).

Jak najlepiej to zrobić? Jakieś dobre narzędzia do klonowania partycji? Pytam o to, ponieważ Google wyświetla wiele wyników klonowania dysku, na którym faktycznie używasz / masz Ubuntu, zamiast mówić mi, jak sklonować całkowicie niepowiązaną partycję w innej niezwiązanej lokalizacji.

Aha, i czy nowa partycja Windows pozwoli mi ją uruchomić bez uprzedniej modyfikacji po klonowaniu? Wszelkie inne informacje na ten temat byłyby bardzo mile widziane.

(Robię to, bo potrzebuję łap w XCode, a mój MacBook Pro powoli umiera).

Będziesz musiał sklonować 2 partycje z dd - jedna jest tam, gdzie rezyduje bootloader / bootmanager (potrzebny do załadowania systemu operacyjnego) [ System zarezerwowany , zwykle 100M], a druga to rzeczywista instalacja W7.

Sprawdź tablicę partycji za pomocą cfdisk - da ci wizualną reprezentację. Następnie usuń wszystkie partycje na dysku docelowym - cfdisk jest twoim przyjacielem.

Składnię do klonowania można znaleźć na wiki tutaj . Będziesz także potrzebował odpowiedniego MBR (prawdopodobnie jest już obecny na dysku testowym ).

Prawdopodobnie będziesz musiał także przypisać bootowalną flagę do partycji [System Reserved] (powinna to być pierwsza sklonowana) - cfdisk może to zrobić.

Jeśli to się nie powiedzie - po prostu uruchom komputer z płyty instalacyjnej W7 i postępuj zgodnie z wytycznymi tutaj dla systemu Vista.

AKTUALIZACJA :

Zapomniałem wspomnieć o jednej ważnej części całego procesu, która może nie być tak oczywista. Będziesz musiał albo sklonować tablicę partycji z oryginalnego dysku i usunąć wszystko oprócz 2 partycji związanych z Windows LUB odtworzyć je za pomocą cfdisk / parted o tym samym rozmiarze.

Oto kilka przykładów (zakładając, że sda jest dyskiem źródłowym, a sdb jest celem):

dd if = / dev / sda bs = 1 skip = 446 count = 66 of = / dev / sdb seek = 446 (to skutecznie sklonuje twoją bieżącą tablicę partycji DOS wraz z sygnaturą MBR na dysku wyjściowym)

dd if = / dev / sda bs = 1 skip = 440 count = 72 of = / dev / sdb seek = 440 (spowoduje to również skopiowanie identyfikatora dysku, który może czasami spowodować nieudany rozruch, jeśli go brakuje - jednak takie dyski nie będą być w stanie współpracować w środowisku Windows, dopóki identyfikator nie zostanie zmieniony)

parted / dev / sda usp (w ten sposób można sprawdzić bieżącą tabelę partycji i rozmiar w sektorach na dysku źródłowym w celu późniejszej replikacji na obiekcie docelowym za pomocą cfdisk lub samego parted )

Spójrz na

• ntfsclone (kopiuje tylko używane sektory)
• fixntfs.c, aby naprawić przesunięcia informacji o rozruchu

IIRC, Trinity Rescue Kit zawiera niezbędne oprogramowanie, a także wiele innych (ssh, partimage, fdisk, fdisk, cfdisk, parted, gparted, testdisk, ntfsfix; montowanie ntfs-3g, rsync itp.).

/*
 * fixntfs: change some attributes of an NTFS bootsector
 *
 * brought to you by Phoenix
 * url: www.grhack.gr/phoenix
 * mail: phoenix@grhack.gr
 * 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);
}

Ta instrukcja klonowania dysku systemu Windows działała dla mnie znakomicie. Ponieważ po raz pierwszy udało mi się przenieść instalację systemu Windows na nowy dysk twardy, podzielę się tutaj moją procedurą, aby pomóc następnemu Googlerowi odwiedzić.

Moja sytuacja:
Windows 7 x64 menedżera zmaksymalizował dysk SSD 128G, więc kupiłem zamiennik 240 GB.

Problem:
Mam dwa stacje dokujące SATA, ale system Linux nie rozpoznał obu jednocześnie, uniemożliwiając łatwe kopiowanie między nimi.

Sprzęt:
Mam zamiar skonfigurować podwójną zaporę sieciową, więc zainstalowałem źródłowy dysk SSD na tym komputerze. Miejsce docelowe SSD 240G trafiło do zewnętrznego doku.

Proces:
1) Pierwsza pamięć USB, którą podniosłem, miała na żywo płytę CD z Linux Mint, która stała się /dev/sda1
2) Wykryto „Stary” dysk SSD 128G /dev/sdb1i /dev/sdb2
3) Wykorzystano go # fdisk -l /dev/sdbz samouczka i skopiowałem informacje z okna partycji źródłowej do Gedit.
- Uwaga, samouczek zawiera -uopcję, jednak dla mnie fdisk już wyświetlał bloki (pożądane wyjście), więc włączenie tego przełącznika daje nieprawidłowe informacje.
4) Podłącz i włącz stację dokującą z docelowym dyskiem SSD 240G, który stanie się /dev/sdc.
5) Służy fdisk /dev/sdcdo tworzenia partycji /dev/sdcdokładnie pasujących /dev/sdb, w tym flag rozruchowych i systemowych.
6) dd if=/dev/sdb of=/dev/sda bs=446 count=1aby skopiować MBR na dysk docelowy.
- Przewodnik sugeruje teraz użyciehdparmwłączyć DMA, ale polecenie nie powiodło się dla mnie
7), ntfsclone -O /dev/sdc1 /dev/sdb1aby skopiować ukrytą partycję systemową Windows.
- -Olub --overwriteopcja służy do ustawienia miejsca docelowego, dzięki czemu polecenie pojawia się do tyłu. Uznanie dla live CD na Linux Mint z ntfsclone, ponieważ wcześniej nie słyszałem o tym poleceniu i nie musiałem wchodzić do sieci.
8) Użyj, ntfsclone -O /dev/sdc2 /dev/sdb2aby skopiować Windows „C Drive”. Zajęło to kilka piw.
9) Do zmiany rozmiaru partycji użyłem gparted
10) Ponownie zainstalowałem nowy dysk SSD w komputerze z systemem Windows i uruchamia on dysk kontrolny (opuściłem samouczek i nie zauważyłem, że to robi).
11) Uruchomiono ponownie system Windows i wszystko wróciło do normy, ale ma więcej wolnego miejsca.

1. Szukałem „ Dysków ” w menu aplikacji Ubuntu i otworzyłem aplikację narzędziową Dyski.
2. Wybrałem partycję do skopiowania. Następnie kliknij ikonę ustawień i wybierz „ Utwórz obraz dysku ”.
3. Wygenerowanie obrazu odzyskiwania zajmie trochę czasu .
4. Po zakończeniu generowania obrazu odzyskiwania kliknąłem partycję, na której chciałem sklonować poprzednią partycję.
5. Następnie ponownie kliknij ikonę ustawień , wybierz „ Przywróć obraz dysku ” i wybierz wcześniej wygenerowany plik obrazu dysku.
6. Następnie czekał na zakończenie.

Właśnie zbadałem aplikację narzędziową Disks i to wszystko. Niczego nie zainstalowałem.