Disk Images Under Linux (建造一个虚拟磁盘)

Linux uses loopback devices for images.

Floppy Disk Images

First, lets create an empty image.

dd if=/dev/zero of=floppy.img bs=512 count=2880

Now, lets set it up for mounting.

losetup /dev/loop0 floppy.img

Now lets make it MSDOS formatted.

mkdosfs /dev/loop0

Mount!

mount -t msdos /dev/loop0 /mnt/myfloppy

---

Hard Disk Images

Caveat

A hard disk image contains an MBR, then a number of partitions, but the 'mount' instruction in Linux works with disk partitions, not full disks. To mount a partition contained in our disk image, we need to make sure the 'mount' command only sees our partition, not the whole disk.

Setting up a new Image

First create the empty file that we will use for our disk image. We will assume a disk geometry of #cylinders, 16 heads, 63 sectors/track, 512 bytes/sector, which means that each cylinder contains 516096 bytes (16*63*512). Decide how large you want your disk image to be, and choose an appropriate number of cylinders (I�ll be using #cylinders throughout).

Example: If I want a 500Mb disk, I would choose 1000 cylinders (approximation of (500*1000*1024)/516096).

Write the disk image (I'll assume the filename c.img throughout):

dd if=/dev/zero of=/path/to/c.img bs=516096c count=#cylinders

Explanation:

dd	Linux command for copy and convert a file
if=/dev/zero	Source file is /dev/zero which is...*drumroll*...an infinite source of zeros
of=/path/to/c.img	Destination file is our disk image (dd will create the file if it doesn't exist)
bs=516096c	Means read and write 516096 bytes at a time (This is just here to keep things simple)
count=#cylinders	Copy this number of blocks. Since we have set bs to 516096 bytes each block is one cylinder long

That leaves us with a nice sized file full of zeros that we'll use for our disk image.

Mounting

Now we attach the file to a loopback device. This lets us treat the file as though it were a physical disk.

Note: Under a normal Linux setup you will need to be root to use the losetup command (The same applies to most commands we'll be using).

losetup /dev/loop0 /path/to/c.img

Explanation:

losetup	Linux command to setup and control loop devices.
/dev/loop0	Loopback device 0. This will become our raw 'disk' device.
/path/to/c.img	File to attach to the the loopback device is our disk image.

If you run ps ax, you should now see a [loop0] process.

Partitioning the Image

Now to create the MBR and partition table on the disk image (Usually you need to be root).

fdisk -u -C#cylinders -S63 -H16 /dev/loop0

Explanation:

fdisk	Linux DOS partition maintenance program.
-u	Display units in sectors not cylinders (We will need this).
-C#cylinders	Set the cylinders of disk to our value.
-S63	Set the sectors/track to 63.
-H16	Set the heads/track to 16.
/dev/loop0	Thanks to losetup this device represents our raw 'disk'.

Within fdisk use the following commands:

o - Create a new empty DOS partition table.
n - Create a new partition (For simplicity just make 1 primary partition covering the whole disk).
a - Toggle the bootable flag (Optional).
p - Print the partition table.

You should end up with a screen that looks something like this:

Disk /dev/loop0: 516 MB, 516096000 bytes
16 heads, 63 sectors/track, 1000 cylinders, total 1008000 sectors
Units = sectors of 1 * 512 = 512 bytes

      Device Boot      Start         End      Blocks   Id  System
/dev/loop0p1   *          63     1007999      503968+  83  Linux

Obviously the cylinder count, partition end and blocks will be different depending on the size of your image.

Make a note of the start sector (63 here) and the block count (503968 here).

Note: If you are intending to format the partition to something other than ext2fs then change the partition id here using the t command. I should also point out that disk manufacturers and programmers don't agree on how many bytes are in a megabyte.

w - Write partition table to our 'disk' and exit.

Ignore any errors about rereading the partition table. Since it's not a physical device we really don't care.

We now have a partition table on our disk image.

Unfortunately this also means that from here on out we have to account for the fact that our partition does not start at byte 0 of the image.

Unmount

Detach our disk image from the loopback device.

Command:

losetup -d /dev/loop0

Explanation:

-d	Detach whatever is on the loopback device

Remount specific partition

Ok, now we attach the file to the loopback device again, but in such a way that we skip everything before the start of our partition.

losetup -o32256 /dev/loop0 /path/to/c.img

Explanation

-o32256	Move the start of data 32256 bytes into the file

The reason we move 32256 bytes into the file is this is where the partition starts. Remember I said to note the start sector of the partition (63 is usual)? Well, since each sector is 512 bytes long we therefore know the starting byte of the partition is 32256 (63*512) bytes into the file. The reason behind this gap is that most (There is no real standard) fdisk programs don't use the first track for anything but the MBR. That space isn't always wasted though, some bootloaders (Eg GRUB) use it to store parts of their program.

Note: If you aren't using the suggested geometry then you'll have to calculate this for yourself.

We now have a device (/dev/loop0) which we can use in a similar fashion to a normal one for a partition (eg /dev/hda1).

Format the partition.

For ext2fs, use:

mke2fs -b1024 /dev/loop0 #blocks

Explanation:

mke2fs	Create an ext2 filesytem
-b1024	Use block size of 1024
/dev/loop0	Device to make the filesystem on (Here /dev/loop0 is our 'partition')
#blocks	Remember I said to note the number of blocks from the fdisk section? This is why.

This gives us a clean ext2 formatted partition.

Note: mke2fs is smart enough to figure out block size and #blocks for itself, but if you ever want to use multiple partitions you'll need to know how to use those values.

For FAT32, use:

mkdosfs -F32 /dev/loop0 #blocks

Explanation:

mkdosfs	Create a DOS filesystem (This may be absent on some Linux systems, search for the dosfstools package if it is)
-F32	FAT 32 allocation tables (It should be obvious how to use FAT12/FAT16)
/dev/loop0	Same as for the ext2fs version
#blocks	Same as for the ext2fs version

This gives us a clean FAT32 formatted partition (Ignore the floppy warning).

Note: The reason for #blocks is the same as for ext2fs, ie possible multiple partitions.

Mount Partition

You should now be able to mount the partition (Because it is still setup on the loopback device).

Command:

mount -text2 /dev/loop0 /mnt/wherever

or

mount -tvfat /dev/loop0 /mnt/wherever

Explanation:

mount	Linux command to mount a filesystem
-text2/-tvfat	Filesystem being used, Linux can usually figure this out on its own.
/dev/loop0	The device representing our PARTITION
/mnt/wherever	A directory to mount the partition on.

This should leave you with a nicely mounted partition. If you run df -Th you should end up with a line similar to:

Filesystem    Type    Size  Used Avail Use% Mounted on
/dev/loop0    vfat    492M  4.0K  492M   1% /mnt/wherever

...or for ext2fs...

Filesystem    Type    Size  Used Avail Use% Mounted on
/dev/loop0    ext2    477M   13K  452M   1% /mnt/wherever

(Yup, these are for the same disk image. By default ext2fs reserves/uses quite a bit of space even empty.)

Unmount, Detach

Ok, unmount the partition and detach the loopback device.

Command:

umount /dev/loop0
losetup -d /dev/loop0

Explanation:

umount	Linux command to unmount a filesystem.
/dev/loop0	The device that was mounted

Making it Easier

One final thing to do, which is to simplify mounting and unmounting that partition.

Command:
Mounting:

mount -text2 -oloop=/dev/loop0,offset=32256 /path/to/c.img /mnt/wherever

Unmounting:

umount /path/to/c.img

Explanation:

This is essentially a combination of the losetup and mount commands we used previously when formatting the partition. If used it also means we lose access to the raw 'disk' or 'partition' through /dev/loop0.

See also http://www.pixelbeat.org/scripts/lomount.sh

The End

That's it, you now know how to handle hard disk images under Linux. Whilst mounted you can use it in exactly the same way you use a normal disk partition. Multiple partitions are an extension of this, just change the offset of the losetup command according to the partition you want to use (And format using the correct number of blocks).

Sample Bochs config line:

ata0-master: type=disk, path=/path/to/c.img, cylinders=#cylinders,heads=16,spt=63

Things to remember:
losetup type command will give you the equivalent of a raw disk device (Eg /dev/hda)
losetup -o type command will give you the equivalent of a raw partition device (Eg /dev/hda1)

--- add on by BeyondInfinity (30052005) ---

Building iso images:

You want to create a bootable iso image?

First you need to build a bootable floppy image which holds f. ex. grub with your menu.lst and your kernel (and additional required modules.

Then, you put this boot floppy image in a temporary directory, say /tmp/deploy.

After that, you copy all your additional files (applications, images, texts, directories too) into the given directory (f. ex. /tmp/deploy).

finally, you are ready to do it:

say:

mkisofs -U -D -floppy-boot -b  boot.img -c boot.catalog -hide boot.img -hide boot.catalog /
-V "Your Name..." -iso-level 3 -L -o /tmp/youriso.iso /tmp/deploy

boot.img,youriso.iso are the names of the boot floppy image and the iso image respectively. change them to your needs. the directories "/tmp/deploy" and "/tmp" you can replace with your own.

The image of the boot floppy has to be in the same directory as the files you want to put into the iso image. you indicate the path relative to the path where your files to deploy to iso are located, that is for our example: the files to deploy are in /tmp/deploy. your boot floppy image is located under /tmp/deploy/boot.img. you tell mkisofs to use boot.img. Keep it relative to the directory the contents of which you want to put in the iso image. (Hope that sentence makes at least some sense)

related thread in the forum: Forum:7822 You gonna find a nifty trick Brendan uses to build his own iso images - with NASM.

--- end add on ---

---

Comments

losetup does not appear to work for users other than root, even when the loop device is chowned to users other than root. However, its advantage over the common "mount -o loop=/dev/loop0" is that your loop device remains available even when unmounted, which should make it easier to work on with tools like mk**fs, grub, etc.

-- Pype.Clicker

Reply: The "loop device" is available for tools like mkfs, grub, etc., as these programs work with files as well as with "devices" (which look like files in any case).

For those of us running a self-build system (e.g. Gentoo) - if you are wondering why you don't seem to have losetup, check whether you have the necessary support enabled in the kernel (Device Drivers -> Block Devices -> Loopback Device Support). While you're at it, you might want to add the losetup lines to a file like /etc/conf.d/local.start (depending on your flavour of Linux) to have it executed automatically on startup.

-- MartinBaute

There's also convienient way of copying files to FAT disk images: mtools. You just have to add line like 'drive x: filename="/my/great/disk/image/file"' and then you can just 'mcopy kernel x:'.

-- Jan Lamecki

  Last edited on June 15, 2006 3:24 pm by "The PhpWiki programming team"