Clonare la partizione Windows da Linux


12

Quindi ho un SSD Intel da 120 GB, con una partizione per Windows e un'altra per Ubuntu. Ubuntu è il mio sistema operativo principale, Windows è per i giochi. Ma ora sto cercando di installare Mac OS X e mi piacerebbe che fosse sull'SSD, quindi sto cercando di spostare Windows su un'altra unità (vecchio esterno da 160 GB che ho estratto dalla sua shell e sono stato usando come test drive. Tengo comunque i miei giochi su un altro esterno, quindi le prestazioni non dovrebbero essere influenzate, a parte il tempo di avvio).

Qual è il modo migliore per farlo? Qualche strumento utile per clonare partizioni? Lo chiedo perché Google sta ottenendo molti risultati sulla clonazione dell'unità su cui stai effettivamente utilizzando / su cui è installato Ubuntu, piuttosto che dirmi come clonare una partizione totalmente non correlata in un'altra posizione non correlata.

Oh, e la nuova partizione di Windows mi consentirà di eseguirla senza alcuna modifica successiva al post-clone? Qualsiasi altra informazione in merito sarebbe molto apprezzata.

(Lo sto facendo perché devo mettere le mie zampe su XCode e il mio MacBook Pro sta lentamente morendo).


Bene, tutto ciò che serve è cfdisk e dd . L'unica cosa in qualche modo discutibile è il settore di avvio. Quale versione di Windows?
XXL

Windows 7. Ricordo di averlo installato come un problema reale, a causa di alcuni problemi relativi alla partizione.
Errore

Hai il disco W7 a tua disposizione?
XXL

Non sono del tutto sicuro di dove l'ho posizionato, ma posso scavarlo se necessario.
Errore

Risposte:


7

Dovrai clonare 2 partizioni con dd - uno è dove risiede il bootloader / bootmanager (necessario per caricare il sistema operativo in catena) [ Riservato al sistema , di solito 100M] e l'altro è l'effettiva installazione di W7.

Controlla la tabella delle partizioni con cfdisk : ti darà una rappresentazione visiva. Quindi elimina tutte le partizioni sull'unità di destinazione: cfdisk è tuo amico.

La sintassi per la clonazione può essere trovata sul wiki qui . Avrai anche bisogno di un MBR adeguato (probabilmente è già presente sul tuo test drive ).

Probabilmente dovrai assegnare un flag di avvio anche alla partizione [Riservato al Sistema] (che dovrebbe essere il primo clonato) - cfdisk può farlo.

Se il problema persiste, eseguire semplicemente l'avvio da un disco di installazione W7 e seguire le linee guida qui per Vista.

AGGIORNAMENTO :

Ho dimenticato di menzionare una parte importante dell'intero processo che potrebbe non essere così evidente. Dovrai o clonare la tabella delle partizioni dall'unità originale ed eliminare tutto tranne le 2 partizioni relative a Windows O ricrearle con cfdisk / parted con le stesse dimensioni.

Ecco alcuni esempi (supponendo che sda sia l'unità sorgente e sdb sia la destinazione):

dd if = / dev / sda bs = 1 skip = 446 count = 66 of = / dev / sdb seek = 446 (questo clonerà efficacemente l'attuale tabella delle partizioni DOS insieme alla firma MBR sull'unità di output)

dd if = / dev / sda bs = 1 skip = 440 count = 72 of = / dev / sdb seek = 440 (questo copierà anche l'ID del disco che a volte può causare un avvio fallito se mancante - tuttavia, tali dischi non lo faranno essere in grado di lavorare insieme su un ambiente Windows, fino a quando l'ID non viene modificato)

parted / dev / sda usp (questo è il modo in cui è possibile controllare la tabella delle partizioni corrente e le dimensioni nei settori sull'unità di origine per una successiva replica sulla destinazione con cfdisk o parted stesso)


Questo è un dolore e di solito non si avvia
vedi il

Perché? Se si verifica un problema con il processo di avvio: l'istanza di una sessione del prompt dei comandi dal disco di installazione di W7 e l'esecuzione di bootrec / fixmbr , bootrec / fixboot o bootrec / rebuildbcd dovrebbero essere in grado di risolvere il problema.
XXL

giusto. L'ho fallito per me in passato. sono sicuro che è per questo che ho scoperto utils per prevenire l'incidente. Inoltre, usare dd per replicare la partizione non è molto efficiente
vedi il

perché usa una copia settore per settore e copia su spazio vuoto nel filesystem allocato? Penso che, nel contesto dei PO, questo probabilmente sarà del tutto irrilevante. Non sappiamo nemmeno se la partizione è piena o no, per non parlare del fatto che si preoccupa di aspettare qualche minuto in più (il guadagno nel tempo potrebbe essere minimo) invece di provare una soluzione alternativa meno chiara
XXL

ma ha il netto vantaggio di poter copiare in una partizione di dimensioni diverse. DD presume che la destinazione abbia esattamente le stesse dimensioni (anche se potrebbe essere più grande ). Questo potrebbe essere un problema che ostacola, specialmente quando sono coinvolti SSD (non hanno una capacità "illimitata" )
vedi il

4

Dai un'occhiata a

  • ntfsclone (copia solo i settori in uso)
  • fixntfs.c per correggere gli offset delle informazioni di avvio

IIRC, Trinity Rescue Kit contiene il software necessario e molti altri (ssh, partimage, fdisk, fdisk, cfdisk, parted, gparted, testdisk, ntfsfix; montaggio ntfs-3g, rsync ecc. Ecc.).

/*
 * 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);
}

2

Questo how-to per la clonazione di un'unità Windows ha funzionato magnificamente per me. Poiché è la prima volta che riesco a trasferire un'installazione di Windows su un nuovo disco rigido, condividerò la mia procedura qui per aiutare il prossimo Googler a visitare.

La mia situazione:
Windows 7 x64 di Manager aveva raggiunto il limite massimo del suo SSD da 128 GB, quindi ho acquistato un sostituto da 240 GB.

Problema:
ho due dock per unità SATA ma Linux non ha riconosciuto entrambi contemporaneamente, impedendo una facile copia tra di loro.

Hardware:
sto per configurare un doppio firewall NIC, quindi ho installato l'SSD di origine in questo computer. L'SSD di destinazione 240G è entrato nel dock esterno.

Processo:
1) La prima chiavetta USB che ho raccolto conteneva un CD live di Linux Mint, che è diventato /dev/sda1
2) Il "vecchio" SSD 128G è stato rilevato e diventato /dev/sdb1e /dev/sdb2
3) Usato # fdisk -l /dev/sdbdal tutorial e copiato le informazioni della finestra della partizione di origine su Gedit.
- Nota, il tutorial include l' -uopzione, tuttavia per me fdisk stava già visualizzando i blocchi (l'output desiderato) quindi includendo quell'interruttore fornisce informazioni errate.
4) Collegare e accendere il dock drive con SSD 240G di destinazione, che diventa /dev/sdc.
5) Utilizzare fdisk /dev/sdcper creare partizioni /dev/sdcesattamente corrispondenti /dev/sdb, inclusi i flag di avvio e di sistema.
6) dd if=/dev/sdb of=/dev/sda bs=446 count=1per copiare l'MBR nell'unità di destinazione.
- La guida ora suggerisce l'utilizzohdparmper attivare DMA, ma il comando non è riuscito per me
7) ntfsclone -O /dev/sdc1 /dev/sdb1per copiare la partizione di sistema nascosta di Windows.
- -Oo l' --overwriteopzione viene utilizzata per impostare la destinazione, facendo apparire il comando all'indietro. Complimenti a Linux Mint live CD con ntfsclone, dato che non avevo mai sentito parlare di questo comando prima e non dovevo entrare in rete.
8) Utilizzare ntfsclone -O /dev/sdc2 /dev/sdb2per copiare Windows "C Drive". Ci vollero alcune birre per completare.
9) Per ridimensionare la partizione, ho usato gparted
10) Reinstallato nuovo SSD nel computer Windows ed esegue checkdisk (avevo lasciato il tutorial e non ho notato che lo fa).
11) Riavviato Windows e tutto è tornato alla normalità ma con più spazio libero.


1
  1. Ho cercato " Dischi " nel menu Applicazioni di Ubuntu e ho aperto l'app di utilità Dischi.
  2. Ho selezionato la partizione da copiare. Quindi fare clic sull'icona delle impostazioni e selezionare " Crea immagine disco ".
  3. Ci vorrebbe un po 'di tempo per generare l'immagine di recupero .
  4. Dopo aver finito di generare l'immagine di ripristino, ho fatto clic sulla partizione in cui volevo clonare la precedente partizione.
  5. Quindi fare nuovamente clic sull'icona delle impostazioni e selezionare " Ripristina immagine disco " e selezionare il file immagine disco generato in precedenza.
  6. Quindi attesi che finisse.

Ho appena esplorato l'app di utilità Disks, e il gioco è fatto. Non ho installato nulla.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.