Vous devrez cloner 2 partitions avec dd - l'un est l'endroit où réside le bootloader/bootmanager (nécessaire pour charger en chaîne le système d'exploitation) [Système réservé , généralement 100M] et l'autre étant l'installation réelle de W7.
Vérifiez la table de partition avec cfdisk - il vous donnera une représentation visuelle. Supprimez ensuite toutes les partitions sur le lecteur cible - cfdisk est votre ami.
La syntaxe pour le clonage peut être trouvée sur wiki ici. Vous aurez également besoin d'un MBR approprié (il est probablement déjà présent sur votre test drive ).
Vous devrez probablement attribuer un amorçable flag à la partition [System Reserved] également (qui devrait être la première clonée) - cfdisk peut accomplir cela.
Si cela échoue, démarrez simplement à partir d'un disque d'installation W7 et suivez les instructions ici pour Vista.
MISE À JOUR :
J'ai oublié de mentionner une partie importante de l'ensemble du processus qui pourrait ne pas être si évidente. Vous devrez soit cloner la table de partition du lecteur d'origine et supprimer tout sauf les 2 partitions liées à Windows OU les recréer avec cfdisk / séparé avec le même taille.
Voici quelques exemples (en supposant que sda est votre lecteur source et sdb est la cible) :
dd if=/dev/sda bs=1 skip=446 count=66 of=/dev/sdb seek=446 (cela clonera efficacement votre table de partition DOS actuelle avec la signature MBR sur le lecteur de sortie)
dd if=/dev/sda bs=1 skip=440 count=72 of=/dev/sdb seek=440 (cela copiera également l'ID du disque, ce qui peut parfois entraîner un échec du démarrage s'il est manquant - cependant, ces disques ne pourront pas fonctionner ensemble dans un environnement Windows tant que l'ID n'aura pas été modifié)
partagé /dev/sda u s p (c'est ainsi que vous pouvez inspecter la table de partition actuelle et la taille des secteurs sur le lecteur source pour une réplication ultérieure sur la cible avec soit cfdisk ou séparé lui-même)
Jetez un oeil à
- ntfsclone (copie uniquement les secteurs en cours d'utilisation)
- fixntfs.c pour corriger les décalages d'informations de démarrage
IIRC, Trinity Rescue Kit contient les logiciels nécessaires ainsi que de nombreux autres (ssh, partimage, fdisk, fdisk, cfdisk, parted, gparted, testdisk, ntfsfix ; montage ntfs-3g, rsync etc. 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(§ors, 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(§ors, 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);
}
Ce guide pour cloner un lecteur Windows a fonctionné à merveille pour moi. Étant donné que c'est la première fois que je peux transférer une installation de Windows sur un nouveau disque dur, je vais partager ma procédure ici pour aider le prochain Googler à visiter.
Ma situation :
Le gestionnaire Windows 7 x64 avait atteint son maximum de 128 Go de SSD, j'ai donc acheté un remplacement de 240 Go.
Problème :
J'ai deux stations d'accueil pour disques SATA mais Linux ne les a pas reconnus en même temps, ce qui empêche une copie facile entre eux.
Matériel :
Je suis sur le point de configurer un pare-feu double NIC, j'ai donc installé le SSD source sur cet ordinateur. Le SSD 240G de destination est entré dans la station d'accueil externe.
Processus :
1) La première clé USB que j'ai récupérée contenait un live CD Linux Mint, qui est devenu /dev/sda1
2) "l'ancien" SSD 128G a été détecté et est devenu /dev/sdb1 et /dev/sdb2
3) Utilisé # fdisk -l /dev/sdb à partir du didacticiel et copié les informations de la fenêtre de la partition source dans Gedit.
-- Notez que le didacticiel inclut le -u option, cependant pour moi, fdisk affichait déjà des blocs (la sortie souhaitée) donc inclure ce commutateur donne les mauvaises informations.
4) Branchez et allumez la station d'accueil du lecteur avec le SSD 240G de destination, qui devient /dev/sdc .
5) Utilisez fdisk /dev/sdc pour créer des partitions sur /dev/sdc qui correspondent exactement à /dev/sdb , y compris les indicateurs de démarrage et système.
6) dd if=/dev/sdb of=/dev/sda bs=446 count=1 pour copier le MBR sur le lecteur de destination.
-- Le guide suggère maintenant d'utiliser hdparm pour activer DMA, mais la commande a échoué pour moi
7) ntfsclone -O /dev/sdc1 /dev/sdb1 pour copier la partition système cachée de Windows.
-- -O ou --overwrite L'option est utilisée pour définir la destination, faisant apparaître la commande à l'envers. Félicitations au live CD Linux Mint ayant ntfsclone, car je n'avais jamais entendu parler de cette commande auparavant et je n'avais pas besoin d'accéder au réseau.
8) Utilisez ntfsclone -O /dev/sdc2 /dev/sdb2 pour copier les fenêtres "C Drive". Cela a pris quelques bières pour terminer.
9) Pour redimensionner la partition, j'ai utilisé gparted
10) Réinstallé le nouveau SSD dans l'ordinateur Windows et il exécute checkdisk (j'avais quitté le tutoriel et je n'avais pas remarqué qu'il le faisait).
11) Redémarré Windows et tout est revenu à la normale mais avec plus d'espace libre.