Executive summary : A Linux user can easily partition a Pata or Sata disk with the gpt partitioning scheme. Most modern Linux will run on gpt disks with little bother but MS Windows will find it an uphill struggle. It is something useful to have when the hard disk exceeds 2TB. The gpt disks can happily co-exist with the non-gpt disks.
I have stayed away from this GUID partition table (GPT) until I bought a 2TB hard disk. The legacy partition table, also called MBR partition table adopted since Dos, has a limitation beyond the 2TB so I was just looking ahead and had a go with the gpt partioning system. A disk partitioned with the legacy type is called Msdos disk whereas a hard disk with a gpt scheme is now called gpt disk.
In theory the gpt partitioning scheme is ready-make for breaking the 2TB barrier in the hard disks. It will cope well with the future 4k physical sector change as well as the resulting alignment problems created. There is a lot of promises so here I am to find it out.
Apparently the GPT partition table is part of the Extensible Firmware Interface (EFI). The former can be implemented in Linux using certain partitioning tools but the latter requires a efi-aware motherboard which is not easy to find. None of my PC has it.
The upshot of it is that the 64-bit MS Windows can be installed and booted if the PC has both efi hardware and gpt hard disk. The 32-bit Windows can never be booted with gpt hard disk. That means the gpt partition table is pretty useless for the majority of the MS systems.
When it comes to Linux the matter is a lot happier and brighter.
To make a gpt disk all we need is to run the "parted" command in a root terminal. To create a gpt hard disk, say for device /dev/sdb, the command is
Code:
parted /dev/sdb
mklabel gpt
The command nukes all existing partitions. To create a partition say from 0Gb to 100Gb is simply
Code:
mkpart Ubuntu 0 100G
quit
The gpt partition table automatically reserves the front end, about 34 sectors or 34x512= 17408 bytes, for the system use. This is a far cry from the Msdos disk that uses 4x16=64 bytes to describe the 4 primary partitions. The MS systems recognise a gpt disk can have 128 partitions. That apparently also applies in Linux as Post #2 shows how I make a 128 partition under 20 seconds!
The gpt partition table is recognised as one partition type ee in all Linux's partitioning tool that do not support gpt because the first 512 bytes sector is common in both gpt and MBR disks. This GPT partition uses up the whole disk. If the disk is larger than 2TB then only the first 2TB will be reported in the protective MBR entry but the GPT partition can be a lot larger. This is how my 500Gb disk looks like after partitioned with "parted" and interrogated by "fdisk".
Code:
bash-3.1# fdisk -l /dev/sdb
WARNING: GPT (GUID Partition Table) detected on '/dev/sdb'! The util fdisk doesn't support GPT. Use GNU Parted.
Disk /dev/sdb: 500.1 GB, 500107862016 bytes
255 heads, 63 sectors/track, 60801 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Disk identifier: 0x2aa773c4
Device Boot Start End Blocks Id System
/dev/sdb1 1 60802 488386583+ ee GPT
bash-3.1#
I have actually created 5 partitions inside using parted but only a few partitioning tools that support gpt can report it. The list from parted looks like this
Code:
bash-3.1# parted -l /dev/sdb
(note: the tabulations of 60 partitions of sda were removed as they are irrelevant)
Model: ATA SAMSUNG HD501LJ (scsi)
Disk /dev/sdb: 500GB
Sector size (logical/physical): 512B/512B
Partition Table: gpt
Number Start End Size File system Name Flags
1 17.4kB 100GB 100GB ext3 Ubuntu
2 100GB 110GB 9999MB ext3 Mepis
3 110GB 120GB 10.0GB ext3 PClinuxOS
4 120GB 130GB 10.0GB ext3 LinuxMint
5 130GB 140GB 9999MB ext3 Slackware
bash-3.1#
Thus the Linux kernel sees the content inside the gpt and the /dev/sdbx partitions can be used as in a normal MBR partition table.
I have installed Ubuntu 10.4 in sdb1 but sdb2 to sdb5 were filled with Mepis, PClinuxOS, Linux Mint and Slackware from other hard disk. They all boot normally with Grub1 but my Linux Mint has Grub2 and I have to manually boot it up first before I could do a Grub-install inside.
I encountered the following interesting points:-
(1) Grub1 if patched can see the partitions inside a gpt disk. The standard 0.97 Grub1 only see gpt disk with one partition type ee and cannot boot the internal partitions. As an example my Mepis has a standard v0.97 Grub1. Although I can chainload Mepis using a patched Grub1 from Ubuntu when Mepis is loaded its standard Grub failed to boot up Mepis, claiming the partition did not exist.
(2) Grub2 has native support for gpt disks so it can be used to boot their internal partitions.
(3) Some older kernel fail to detect the internal partitions of a gpt disk. As an example I am now using Slackware with a 2.6.29 kernel. I managed to boot it up from sdb5 and was using it, yet when I attempted to mount /dev/sdb2 I got an error message of
mount: special device /dev/sdb2 does not exist
. Its /dev directory only has sdb1 device name. Thus the gpt support is still not mature in Linux.
(4) The UUID numbering system appears to originate from gpt partitioning system.
(5) Without efi hardware support from the motherboard I could not install any of the 64 bit MS Windows on the gpt disk. For the 32 bit MS system the gpt is a no-go area because the internal partitions won't get mounted at all. This means a ntfs partition created by a 64-bit Win7 cannot be seen in a Xp home. And I originally thought gpt partition table was invented for the MS systems.
(6) Any hard disk can be created in gpt format. I have tried it on both 500Gb and 2Tb hard disks.
(7) The partition type numbers appear to have been dropped in gpt system.
(8) A gpt partition table to a non gpt-aware partitioning tool like fdisk, cfdisk or sfdisk is similar to a LVM partition or an extended partition. It show up as one entry but there can be several partitions inside it.
(9) When a hard disk is partitioned in gpt the entire space is used up. A maximum of 128 partitions can be created (as showed in Post #2).
I shall add references to this thread about gpt in the space below from time to time
My script is supposed to generate 180 partitions each 10Gb large but the following error was reported. Here is part of the print out where parted objected to.
Code:
(parted) mkpart sde120 1190001m 1200000m
(parted) mkpart sde121 1200001m 1210000m
(parted) mkpart sde122 1210001m 1220000m
(parted) mkpart sde123 1220001m 1230000m
(parted) mkpart sde124 1230001m 1240000m
(parted) mkpart sde125 1240001m 1250000m
(parted) mkpart sde126 1250001m 1260000m
(parted) mkpart sde127 1260001m 1270000m
(parted) mkpart sde128 1270001m 1280000m
(parted) mkpart sde129 1280001m 1290000m
Error: Too many primary partitions.
(parted) mkpart sde130 1290001m 1300000m
Error: Too many primary partitions.
(parted) mkpart sde131 1300001m 1310000m
Error: Too many primary partitions.
(parted) mkpart sde132 1310001m 1320000m
Error: Too many primary partitions.
(parted) mkpart sde133 1320001m 1330000m
Error: Too many primary partitions.
(parted) mkpart sde134 1330001m 1340000m
Error: Too many primary partitions.
(parted) mkpart sde135 1340001m 1350000m
The 128 partition limit is to match what MS systems have been designed to support.
It is also interesting to see that even I specified the first partition to start from 1st Mb of the hard disk Parted overruled me to start at 17.4k which is exactly at the 34th sector. As my 2TB Samsung disk has 512 bytes per sector (both physical and logical) 34*512 = 17408 bytes or 17.4k.
A gpt partition table has
Sector 1 for the protective MBR
Sector 2 for the primary header
Sector 3 to 34 for storing the 128 partition entries. Each partition entry has 128 bytes. Details as per Wikipedia on GUID Partition Table
Proof of the pudding in the eating
To prove these partitions work I tried to install a Linux at the 128th partition while using the 1st partition as a swap. Ubuntu seems to take too long and I lost patience. I tried Open Suse 11.3. It apparently has a Grub1 that failed to get installed and the distro became inoperable.
Finally I installed Fedora 13 X86_64 Live-KDE in the 128th partition and its Grub1 failed again, leaving me with an installed Linux without a boot loader. However I slip in a Grub2 floppy and fired it up manually. I am using this Fedora to add information to the current post. The /boot/grub/grub.conf gave it away that Fedora has only Grub1. The content of /boot/grub directory is nearly empty and the grub.conf has nothing inside.
Code:
[root@localhost saikee]# ls /boot/grub
grub.conf splash.xpm.gz
[root@localhost saikee]# cat /boot/grub/grub.conf
# grub.conf generated by anaconda
#
# Note that you do not have to rerun grub after making changes to this file
# NOTICE: You do not have a /boot partition. This means that
# all kernel and initrd paths are relative to /, eg.
[root@localhost saikee]#
set root=(hd1,128)
linux /boot/vmlinuz-2.6.33.3-85.fc13.x86_64 ro root=/dev/sdb128
initrd /boot/initramfs-2.6.33.3-85.fc13.x86_64.img
boot
The green bits were not typed but using the tab key to complete.
When installing Fedora I removed one of the hard disks making the gpt disk changed from sde to sdb.
Some bad news
(1) If the distro has unpatched Grub1 of V0.97 then the installation can fail with the bootloader unable to read the gpt partition table. The only way out is to boot up the system manually with Grub2 and then install Grub2 inside.
(2) Grub1, even if patched and able to read a gpt can have an issue of "Selected cylinder exceeds the maximum supported by the BIOS". This happened to me when I tried to use a patched Grub1 from Ubuntu to boot the Fedora in sdb128 which is at the 1280Gb position of the hard disk.
(3) A distro may have components able to read a gpt yet another component not arranged to service it. An example is Slax and Slackware which have "parted" to show up the 128 partitions yet in the /dev directory only the first partition has been detected and has just the device name /dev/sdb1 available. Some distros may list only the first 15 partitions too if the other are detected.
(4) Even if the Linux is fully able to work with 128 partitions its installer may not have been written to cope with such a high number of partitions. Typically the installer may freeze in such an encounter.
(5) I found out two issues with Grub1. (1) The standard Version 0.97 cannot read a gpt disk. This can be overcome by the patched Grub1 available from Ubuntu, Mandriva and Slackware family distros. Just replace the two files stage1 and stage2 in the /boot/grub directory is all one needs. (2) Grub1 even patched will not be able to boot systems located beyond at about 1340Gb in the hard disk. The error is "The cylinder exceeds the maximum supported by the BIOS". So far the only cure is to switch to Grub2. This error applies to both Msdos and gpt disks.
It is one of the several partitioning schemes for a hard disk. Most of us use Msdos partition table in Linux.
(2) Why can't I stick with the existing Msdos partition table?
Yes you can. It is just in the Msdos partition table each partition is defined by 16 bytes. The last 2 sets of 4-bytes describe the hard disk position and the number of sectors of the partition. There are 42 bits in 4 bytes and 2^32*512 bytes per sector=2TB. Thus hard disks or RAID exceeding 2TB cannot use Msdos partition table.
Can I partition any hard disk with gpt scheme?
I haven't tried Pata disk but there does not seem to be any problem with Sata disk.
What tool in Linux can we use to do gpt partitions?
Parted is the main tool. But Gparted and gdisk (also sgdisk) also do gpt partitions.
Does Linux kernel support gpt?
There were information indicating gpt supports started in 2000 in Linux. Most distros have no problem with it. Some installers may not have been written to install in a gpt disk. From my experience I haven't found an installer from Slackware family able to read a gpt disk. Its kernel doesn't boot from it but has the program "parted" and so able to see it.
Linux in general has little problem in using a gpt partitions in exactly the same way as any partition.
Do other operating systems support gpt?
MS Windows seem to go in a big way to promote gpt but with 200% effort of Linux to get 25% out of it. All 32-bit MS Windows, possibly the majority of the desktops, are totally blind to gpt because they can't mount it. A 64-bits MS Windows can only boot from gpt if the motherboard is equipped with efi hardware.
Apple has gone in a big way to support gpt and able to make a good use of it.
BSD systems are like Linux -- no problem!
Can Linux boot loaders cope with gpt?
Since I can't get a Slackware family distro to recognise a gpt disk so I haven't been able to test Lilo fully. I did manage to install Mandriva into the gpt sda7 partition and opted for Lilo as its boot loader. That boot up successfully first in MBR and then withing sda7 when chainloaded by another bootloader. Lilo has a limit not able to recognise a partition number higher than 15 so it is not a big player in booting Linux. There seem to a fair bit of criticism Lilo failing gpt and I did find it behaving differently between a Msdos and gpt disks.
Standard Grub1 cannot read a gpt disk. This is not a big deal because a standard Grub1 also can't read the Ext4 filing system too but can be "doctored" to do so. Many distros now have Grub1, patched to recognise gpt as well as Ext4, able to read gpt disks. If Grub1 can read gpt it can boot from it.
Grub2 has been engineered to read gpt from day 1.
How does a gpt disk respond in the normal partitioning scheme?
A gpt partitioning scheme retains the MBR layer and has been given Type number "ee". It works just live a LVM (Type 8e). You only see one partition displayed but there can be several components inside. The partition types supported by Linux are :-
Code:
0 Empty 24 NEC DOS 81 Minix / old Lin bf Solaris
1 FAT12 39 Plan 9 82 Linux swap / So c1 DRDOS/sec (FAT-
2 XENIX root 3c PartitionMagic 83 Linux c4 DRDOS/sec (FAT-
3 XENIX usr 40 Venix 80286 84 OS/2 hidden C: c6 DRDOS/sec (FAT-
4 FAT16 <32M 41 PPC PReP Boot 85 Linux extended c7 Syrinx
5 Extended 42 SFS 86 NTFS volume set da Non-FS data
6 FAT16 4d QNX4.x 87 NTFS volume set db CP/M / CTOS / .
7 HPFS/NTFS 4e QNX4.x 2nd part 88 Linux plaintext de Dell Utility
8 AIX 4f QNX4.x 3rd part 8e Linux LVM df BootIt
9 AIX bootable 50 OnTrack DM 93 Amoeba e1 DOS access
a OS/2 Boot Manag 51 OnTrack DM6 Aux 94 Amoeba BBT e3 DOS R/O
b W95 FAT32 52 CP/M 9f BSD/OS e4 SpeedStor
c W95 FAT32 (LBA) 53 OnTrack DM6 Aux a0 IBM Thinkpad hi eb BeOS fs
e W95 FAT16 (LBA) 54 OnTrackDM6 a5 FreeBSD ee GPT
f W95 Ext'd (LBA) 55 EZ-Drive a6 OpenBSD ef EFI (FAT-12/16/
10 OPUS 56 Golden Bow a7 NeXTSTEP f0 Linux/PA-RISC b
11 Hidden FAT12 5c Priam Edisk a8 Darwin UFS f1 SpeedStor
12 Compaq diagnost 61 SpeedStor a9 NetBSD f4 SpeedStor
14 Hidden FAT16 <3 63 GNU HURD or Sys ab Darwin boot f2 DOS secondary
16 Hidden FAT16 64 Novell Netware af HFS / HFS+ fb VMware VMFS
17 Hidden HPFS/NTF 65 Novell Netware b7 BSDI fs fc VMware VMKCORE
18 AST SmartSleep 70 DiskSecure Mult b8 BSDI swap fd Linux RAID auto
1b Hidden W95 FAT3 75 PC/IX bb Boot Wizard hid fe LANstep
1c Hidden W95 FAT3 80 Old Minix be Solaris boot ff BBT
1e Hidden W95 FAT1
The command
Code:
fdisk -l
yields
Code:
WARNING: GPT (GUID Partition Table) detected on '/dev/sda'! The util fdisk doesn't support GPT. Use GNU Parted.
Disk /dev/sda: 500.1 GB, 500107862016 bytes
255 heads, 63 sectors/track, 60801 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Disk identifier: 0x2aa773c4
Device Boot Start End Blocks Id System
/dev/sda1 1 60802 488386583+ ee GPT
whereas the command
Code:
sfdisk -l
Code:
WARNING: GPT (GUID Partition Table) detected on '/dev/sda'! The util sfdisk doesn't support GPT. Use GNU Parted.
Disk /dev/sda: 60801 cylinders, 255 heads, 63 sectors/track
Units = cylinders of 8225280 bytes, blocks of 1024 bytes, counting from 0
Device Boot Start End #cyls #blocks Id System
/dev/sda1 0+ 60801- 60802- 488386583+ ee GPT
start: (c,h,s) expected (0,0,2) found (0,0,1)
/dev/sda2 0 - 0 0 0 Empty
/dev/sda3 0 - 0 0 0 Empty
/dev/sda4 0 - 0 0 0 Empty
The fully contents of a gpt disk is only visible currently with parted command but GUI commands like Gparted also privides a full list.
Can a Linux be moved from a Msdos disk to a gpt disk?
Yes subject to the normal rules of migrating to a different partition.
In the above sda disk I only installed Ubuntu but moved Mepis, PCLinuxOS, LinuxMint and Slackware from a Msdos disk. They were in different partition numbers too. All of them boot except the Slackware.
A brief rundown of Linux migration of Mepis, PCLinuxOS, Linux Mint and Slackware:
(1) I had to mount the distro at its new location, edit /etc/fstab and /boot/grub/menu.lst (for Grub1) or /boot/grub/grub.cfg(for Grub2) to reflect the new location.
(2) For Grub1 I simply use a Grub shell or Grub prompt to restore Grub it the distro's root partition. Say this is /dev/sda2 the Grub commands are just
Code:
root (hd0,1)
setup (hd0,1)
(3) For Grub2 I had to boot manually into the Linux and do a grub-install. For within its root partition, say sda1, will be
Code:
grub-install --force /dev/sda1
for choosing that distro to take control of MBR then the command will be
Code:
grub-install /dev/sda
(4) I then edited the Grub menu of distro controlling the MBR to chainload all the others.
Mepis has a standard Grub1. When it booted Grub1 cannot mount any partition so I ended up with a Grub prompt. PCLinuxOS and Slackware have patched Grub1 so I simply copied their stage1 and stage2 files from /boot/grub directory into Mepis. I did the "root" and "setup" commands again and Mepis boots successfully in the gpt disk.
Ubuntu and Linux Mint use Grub2 so they booted immediately after the migration.
PCLInuxOS does not like the migration of being moved from sda39 to sda3. It waits 2 minutes for sda39 to appear. After the 2 minutes it boots up normally. This is a speciality of Mandriva family and I have not found a cure to avoid the 2 minutes waiting yet.
Slackware doesn't boot! It panic complaining could not find sda5. The boot up message shows only sda1 was detected so its kernel can't read a gpt disk. I then tried to install several Slackware family distros and none of them can see the partitions inside.
After trying the gpt on Pata and Sata disks I thought some of the pointers mat be useful to others.
(A) Do the gpt scheme first and the partitions later.
This is because I prefer the partitioning with a script with which I could check first before going ahead. To make a hard disk do gpt one just needs a command but it pays to check the disk before and after as I explain with the following example. The red entries are my input while the rest is from the Linux.
Code:
linux-ijwr:/home/saikee # parted /dev/sdb
GNU Parted 2.2
Using /dev/sdb
Welcome to GNU Parted! Type 'help' to view a list of commands.
(parted) p
Model: ATA SAMSUNG HD154UI (scsi)
Disk /dev/sdb: 1500GB
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Number Start End Size Type File system Flags
1 24.7MB 60.4GB 60.4GB primary boot, type=bf
(parted) mklabel gpt
Warning: The existing disk label on /dev/sdb will be destroyed and all data on this disk will be lost. Do you want to continue?
Yes/No? yes
(parted) p
Model: ATA SAMSUNG HD154UI (scsi)
Disk /dev/sdb: 1500GB
Sector size (logical/physical): 512B/512B
Partition Table: gpt
Number Start End Size File system Name Flags
(parted) q
Information: You may need to update /etc/fstab.
The first command "parted /dev/sdb" is to commit myself to partition device sdb. When inside parted I issued the first "p" to print out the existing partition table, which is a Solaris Type "bf" I wished to ditch.
The main command to turn the disk to gpt is "mklabel gpt".
Parted wants a confirmation for safety so I answer with a "yes". I then issued the 2nd "p" to print the latest partition table which now show up empty. I then issued "q" to exit parted.
(B) Partioning by a script
To do partition I find enjoyment of doing it by a script so I used an editor to write a file called "parted_sda_10_partition"
Code:
linux-ijwr:/home/saikee # cat parted_sda_10_partition
for ((i=1;i<=10;i++));
do k1=$[(i-1)*20000+1]
k2=$[i*20000];
echo "mkpart Partition_$i $[k1]m $[k2]m";
done > a2 ;
echo "q">>a2
One can issue it as a bash script to generate a text file called a2.
It is interesting to see the 64-bit sees the gpt disk as its own and attempts to mount all the partitions by assigning a letter to each until the drive letter runs out at z:. Then it stops.
This is a very unusual behaviour because a standard MS Windows does not mount a partition, gives it a drive letter if the filing system is not recognised. Yet it goes all its way to do it for the gpt disk.
I have also long been puzzled by MS Windows calling every partition it doesn't recognised or with a vaild filing system as a "primary" partition.
(B) gpt is a no go area for MS boot loaders
MS boot loaders from Dos, Win2k, Xp, Vista and Win7 all work on the principle that any one of the 4 primary partitions with the booting flag set "on" shall be booted. There is no distinction between primary and logical partition in a gpt disk and there can be potentially 128 partitions in each. Thus the MS boot loaders break down completly with a gpt disk. No wonder none of the 32 bit MS Windows can boot from a gpt disk.
The 64-bit MS Windows can boot from a gpt disk only if the motherboard is equipped with the efi hardware which provides its own boot loader. This will be very hard to catch on. In the mean time many MS Windows systems are reaching the end of the road with a hard disk limited at 2TB. May be the 4k physical block addressing will buy them some extra time.
The superiority of the Linux boot loaders is evident when comparing with the MS systems.
It comes no surprise that I found Lilo and Grub can work normally with a gpt disk.
Linux kernel is a lot saner when coming to partitions. Unless one specifies them in /etc/fstab none of the partitions will be mounted. If a user wants he/she can always mounts a partition manually or automatically with fstab.
A MS Windows system tends to be obssessed with other systems using their resources so on every boot-up it will go through every partition in each hard disk. This takes a long time and doing the disk no good at all.
I have been using a 500GB SATA drive (same model as your example - Samsung 501LJ) which is (somehow) a GPT format (I probably had OSX on there at some point).
I used to boot off a third (unused) NTFS MBR formatted drive, so the bootloader is still intact on that HDD I believe. My problem is THIS, I have transferred the drive to a new machine, and it now will not boot Linux (Mint 10 Julia). There is probably a very simple fix to this, probably replacing the MBR (GPT?) with a simple dd line.
For an OS that supports GPT, I am having a nightmare getting grub reinstalled off the boot CD.
I now have the linux boot drive connected via a PCI Sata card, which identifies the disk as SCSI I believe, although it mounts fine with a default mount command. All the files on the disk look intact...
Any help would be very useful to me... You should be able to email me via this forum.
I think your boot loader might have been broken by the disk order as you seem to several hard disk so there would have been a disk order 0, 1, 2 etc.
The MBR for a MSdos and gpt partition disk is the same. The only difference is a gpt has a large boot sector storing all the necessary information for the 128 partitions. It also has a dulpication of its partition table at the rear end of the disk making salvage work possible.
As far as I am aware Grub2 works with gpt disks the same way as MSdos disks so your rescue lies with identify the correct disk and partition if the Grub2 has been installed into the gpt disk.
For assistance you will have to describe the situation before the change and after the change. Location of the boot loader, which should be in one of the Linux, /boot/grub/grub.cfg, /boot/grub/device.map and /etc/fstab will helps us to understand your configuration.
As a rule you should be able to restore Grub2 with any Linux Live CD that has Grub2 inside.
How Seagate manage a 3TB to suit operating systems
Bought a 3TB external hard disk today. It is one of those Seagate Geoflex series. It does not have a gpt partition table but a special or interesting Msdos partition table
The saying is a 32-bit operating system has a limit of addressing up to a maximum just below 2.2TB and so this becomes the limit of the MSDOS partition table based on each record the hard disk read or write is 512 bytes.
The trend is go for the gpt partition table but that is still too immature or too new for many PC users.
Seagate in order to sell their 3TB hard disks has increased the sector size from 512 bytes to 4096 bytes. Thus the number of records to search is artificially reduced so that the hard disk hooked up as an external drive (not required for booting) can be used by the common operating systems.
Here is the disk geometry of Seagate 3TB hard disk, factory-preformatted to one NTFS partition.
Code:
Note: sector size is 4096 (not 512)
Disk /dev/sdb: 3000.6 GB, 3000592977920 bytes
1 heads, 7 sectors/track, 104652377 cylinders
Units = cylinders of 7 * 4096 = 28672 bytes
Sector size (logical/physical): 4096 bytes / 4096 bytes
I/O size (minimum/optimal): 4096 bytes / 4096 bytes
Disk identifier: 0xa4b57300
Device Boot Start End Blocks Id System
/dev/sdb1 2 104652001 2930256000 7 HPFS/NTFS
Partition 1 does not start on physical sector boundary.
Thus the hard disk is still reading 512 bytes per sector physically but the controller of the external hdd enclosure changes it to 4096 bytes.
This 3TB USB disk is automatically mounted by Xp (32-bit), Win7 (64-bit) and Ubuntu (32-bit) and operates normally.
hi saikee
i have a T420s with a 160GB SSD and i have discovered (i am a newbie:-) ) that
the disk label is msdos and i want as little as possible from MS so i booted from a live-USB and changed the disk label to GPT and reinstalled linux mint 12. but now when i switch on the computer, it doesnt even load the grub.. the only error message is: exiting intel boot agent.. any suggestions?
It sounds to me that you might have not installed Grub properly so that the computer trying to obtain a boot code from the Intel booting agent which I assume is the one residing in the PC hardware.
What you can do is to boot up the Mint CD and post here the output of
Code:
sudo su
fdisk -l
parted -l /dev/sda
to confirm the disk partitions. The "l" in the above is the lower case of "L". The Mint CD should enable you to use the Internet.
ok, but in all distros i ve tried (except arch) one can just partition the disk manually and click: install bootloader on /dev/sd*.. can one install a live cd with command line tools to have more control?
here are my outputs: (i'm not sure if i've changed something since installation, i've maybe messed around with..)
PHP Code:
mint mint # fdisk -l
WARNING: GPT (GUID Partition Table) detected on '/dev/sda'! The util fdisk doesn't support GPT. Use GNU Parted.
Disk /dev/sda: 160.0 GB, 160041885696 bytes
255 heads, 63 sectors/track, 19457 cylinders, total 312581808 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x00000000
Device Boot Start End Blocks Id System
/dev/sda1 1 312581807 156290903+ ee GPT
PHP Code:
mint mint # parted -l /dev/sda
Model: ATA INTEL SSDSA2BW16 (scsi)
Disk /dev/sda: 160GB
Sector size (logical/physical): 512B/512B
Partition Table: gpt
Number Start End Size File system Name Flags
1 17.4kB 10.0GB 10.0GB ext4
2 10.0GB 50.0GB 40.0GB ext4
3 50.0GB 62.0GB 12.0GB linux-swap(v1)
Warning: Unable to open /dev/sr0 read-write (Read-only file system). /dev/sr0
has been opened read-only.
Error: Invalid partition table - recursive partition on /dev/sr0.
Ignore/Cancel?
Reply With Quote
Great Stuff
Bookmarks