Clonar partición de Windows desde Linux

Así que tengo un SSD Intel de 120 GB, con una partición para Windows y otra para Ubuntu. Ubuntu es mi sistema operativo principal, Windows es para juegos. Pero ahora estoy buscando instalar Mac OS X, y me gustaría que esté en el SSD, así que estoy buscando mover Windows a una unidad diferente (antigua 160 GB externa que saqué de su shell y he estado uso como prueba de manejo. De todos modos, mantengo mis juegos en otro externo, para que el rendimiento no se vea afectado, excepto el tiempo de inicio

¿Cuál es la mejor manera de hacer esto? ¿Alguna buena herramienta para clonar particiones? Pregunto esto porque Google está obteniendo muchos resultados al clonar la unidad que realmente está usando / tiene Ubuntu instalado, en lugar de decirme cómo clonar una partición totalmente no relacionada en otra ubicación no relacionada.

Ah, ¿y la nueva partición de Windows me permitirá ejecutarla sin ningún ajuste previo posterior a la clonación? Cualquier otra información sobre esto sería muy apreciada.

(Estoy haciendo esto porque necesito poner mis patas en XCode, y mi MacBook Pro se está muriendo lentamente).

Tendrá que clonar 2 particiones con dd : una es donde reside el gestor de arranque / gestor de arranque (necesario para cargar en cadena el sistema operativo) [ Sistema reservado , generalmente 100M] y la otra es la instalación real de W7.

Verifique la tabla de particiones con cfdisk : le dará una representación visual. Luego, elimine todas las particiones en la unidad de destino: cfdisk es su amigo.

La sintaxis para la clonación se puede encontrar en wiki aquí . También necesitará un MBR adecuado (probablemente ya esté presente en su prueba de manejo ).

Probablemente también necesite asignar un indicador de arranque a la partición [Sistema reservado] (que debería ser el primero clonado); cfdisk puede lograrlo.

Si eso falla, simplemente inicie desde un disco de instalación W7 y siga las pautas aquí para Vista.

ACTUALIZACIÓN :

Olvidé mencionar una parte importante de todo el proceso que podría no ser tan evidente. Tendrá que clonar la tabla de particiones de la unidad original y eliminar todo menos las 2 particiones relacionadas con Windows O recrearlas con cfdisk / parted con el mismo tamaño.

Aquí hay algunos ejemplos (suponiendo que sda es su unidad fuente y sdb es el objetivo):

dd if = / dev / sda bs = 1 skip = 446 count = 66 of = / dev / sdb seek = 446 (esto clonará efectivamente su tabla de partición de DOS actual junto con la firma MBR en la unidad de salida)

dd if = / dev / sda bs = 1 skip = 440 count = 72 of = / dev / sdb seek = 440 (esto también copiará la ID del disco que a veces puede resultar en un inicio fallido si falta, sin embargo, tales discos no poder trabajar juntos en un entorno Windows, hasta que se cambie la ID)

parted / dev / sda USP (así es como se puede inspeccionar la tabla de particiones actual y el tamaño de los sectores en la unidad de origen para la replicación posterior en el objetivo, ya sea con cfdisk o separado en sí)

Mira esto

• ntfsclone (solo copia sectores en uso)
• fixntfs.c para arreglar las compensaciones de información de arranque

IIRC, Trinity Rescue Kit contiene el software necesario y muchos otros (ssh, partimage, fdisk, fdisk, cfdisk, parted, gparted, testdisk, ntfsfix; montaje ntfs-3g, rsync, etc.).

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

Este procedimiento para clonar un disco de Windows funcionó espléndidamente para mí. Como esta es la primera vez que puedo transferir una instalación de Windows a un nuevo disco duro, compartiré mi procedimiento aquí para ayudar al próximo Googler a visitar.

Mi situación:
el Windows 7 x64 de Manager había maximizado su SSD de 128G, así que compré un reemplazo de 240 GB.

Problema:
Tengo dos bases para unidades SATA, pero Linux no reconoció ambas al mismo tiempo, lo que impidió una copia fácil entre ellas.

Hardware:
estoy a punto de configurar un firewall dual NIC, así que instalé el SSD de origen en esta computadora. El SSD 240G de destino entró en un muelle externo.

Proceso:
1) La primera memoria USB que tomé tenía el CD en vivo de Linux Mint, que se convirtió en /dev/sda1
2) Se detectó y se convirtió en SSD 128G "Viejo" /dev/sdb1y /dev/sdb2
3) Se usó # fdisk -l /dev/sdbdel tutorial y copió la información de la ventana de partición de origen a Gedit.
- Tenga en cuenta que el tutorial incluye la -uopción, sin embargo, para mí, fdisk ya estaba mostrando bloques (la salida deseada), por lo que incluir ese interruptor proporciona la información incorrecta.
4) Enchufe y encienda la unidad dock con SSD 240G de destino, que se convierte en /dev/sdc.
5) Utilícelo fdisk /dev/sdcpara crear particiones /dev/sdcque coincidan exactamente /dev/sdb, incluidos los indicadores de arranque y del sistema.
6) dd if=/dev/sdb of=/dev/sda bs=446 count=1para copiar el MBR a la unidad de destino.
- La guía ahora sugiere usarhdparmpara encender DMA, pero el comando falló para mí
7) ntfsclone -O /dev/sdc1 /dev/sdb1copiar la partición oculta del sistema de Windows.
- -Oo la --overwriteopción se usa para establecer el destino, haciendo que el comando aparezca al revés. Felicitaciones a Linux Mint live CD con ntfsclone, ya que no había oído hablar de este comando antes y no tuve que conectarme a la red.
8) Utilícelo ntfsclone -O /dev/sdc2 /dev/sdb2para copiar la ventana "Unidad C". Esto tomó unas cervezas para completar.
9) Para cambiar el tamaño de la partición, utilicé gparted
10) Reinstalé un nuevo SSD en la computadora con Windows y ejecuta checkdisk (había dejado el tutorial y no me di cuenta de que lo hacía).
11) Reinició Windows y todo volvió a la normalidad, pero con más espacio libre.

1. Busqué " Discos " en el menú de aplicaciones de Ubuntu y abrí la aplicación de utilidad Discos.
2. Seleccioné la partición para copiar. Luego hizo clic en el icono de configuración y eligió " Crear imagen de disco ".
3. Llevaría un tiempo generar la imagen de recuperación .
4. Una vez que terminó de generar la imagen de recuperación, hice clic en la partición donde quería clonar la partición anterior.
5. Luego hizo clic en el icono de configuración nuevamente, y seleccionó " Restaurar imagen de disco " y seleccionó el archivo de imagen de disco generado previamente.
6. Luego esperé a que terminara.

Acabo de explorar la aplicación de utilidad Disks, y eso es todo. No instalé nada.