Tag Archives: live CD

libguestfs: Live CD inspection

New in libguestfs 1.9.4, you can now run virt-inspector on some types of installer CD and live CD. The output tells you what type of operating system is on the CD:

$ virt-inspector cd.iso
<?xml version="1.0"?>
<operatingsystems>
  <operatingsystem>
    <root>/dev/sda</root>
    <name>windows</name>
    <arch>x86_64</arch>
    <distro>windows</distro>
    <product_name>Windows Server 2003 Enterprise x64 Edition</product_name>
    <major_version>5</major_version>
    <minor_version>2</minor_version>
    <windows_systemroot>\WINDOWS</windows_systemroot>
    <format>installer</format>
    <mountpoints>
      <mountpoint dev="/dev/sda">/</mountpoint>
    </mountpoints>
    <filesystems>
      <filesystem dev="/dev/sda">
        <type>iso9660</type>
        <label>CRMEXFPP_EN</label>
      </filesystem>
    </filesystems>
    <applications/>
  </operatingsystem>
</operatingsystems>

Update

On IRC someone asked me how long this takes. Here is the time to run the above command on my laptop:

real	0m4.736s
user	0m1.134s
sys	0m2.897s

The use case is in tools like virt-manager where we would like to detect what sort of ISO a user is installing from so that we can set the OS hints correctly. 5 seconds is just about acceptable as long as this happens in the background and doesn’t disturb the UI.

Leave a comment

Filed under Uncategorized

Prebuilt distributions part 3

[This is the final article in a three part series. Read part 1 and part 2.]

In this part I was going to discuss the different installation options, and I’ll give a quick introduction to each at the end. But you know? What I really need is this tool:

+--------------------------------------------------------+
| Rich's Amazing Bug Environment Reproducer Tool!        |
+--------------------------------------------------------+
| Bugzilla number: # [545116] [ Go ]                     |
|                                                        |
| Preselecting Fedora Rawhide image.  If this is wrong,  |
| choose the right image from the list below:            |
|                                                        |
| [X] Fedora Rawhide (x86-64)                            |
| [ ] Fedora 12                                          |
| [ ] Fedora 11                                          |
| [ ] Ubuntu 9.11                                        |
| [ ] Ubuntu 9.04                                        |
| [ ] Debian 6.0                                         |
| [ ] Debian 5.0    [Download more distributions]        |
|                                                        |
| [X] x86-64   [ ] i386                                  |
|                                                        |
| [Create  virtual machine now]                          |
+--------------------------------------------------------+

The Create virtual machine now button must take no more than 60 seconds to deliver the virtual machine, plus maybe another 60 seconds to boot it and give me the login prompt. I can then go in, configure it and reproduce the bug, and snapshot it, so I can go back and test fixes later. (I’d like the snapshot workflow to go through the user interface too, and ponies).

The only approach that doesn’t take ages to install is to have the distributions prebuilt as small disk images locally (as described already in part 2).

Note stuff I don’t want to have to specify: storage, download URLs, VM names, etc etc.

Why doesn’t this exist already, or perhaps it does?

I’d also like to suggest that the resizable disk image should become yet another distribution format that Linux distros provide. Many do already, albeit buried inside a live CD.


As promised, my quick summary of installation methods:

virt-install

virt-install is a great command line tool for installing new VMs. I have these two commands pretty much permanently in my command history:

# lvcreate -n F13Rawhidex64 -L 10G vg_trick
# virt-install -v -n F13Rawhidex64  --accelerate \
    -r 512 -f /dev/vg_trick/F13Rawhidex64 \
    --cdrom Fedora-12-x86_64-DVD.iso

The commands above lead to a manual installation, but you can also specify a kickstart file, although the syntax for doing this is not obvious and not documented in the manual page.

Nevertheless, even an install from a CD-ROM on the local drive (as in the example above) is a slow process, taking anything up to an hour.

kickstart

Kickstart is the method used to automate Anaconda installs, ie. installs of all Fedora, Red Hat and derived distributions. It’s a little unwieldy because you have to write a separate kickstart file, then host that on a web server (so the VM can find it), then add a special magic kernel parameter when booting the VM: ks=http://local.example.com/kickstart.ks

I found in the past that it’s better to keep a collection of kickstart files around and iterate them slowly so you can find out what works and what doesn’t.

Also, kickstarts are automatic, but just as slow as manual installation.

debootstrap

Debian’s debootstrap (and the Fedora equivalent I wrote called febootstrap) is, as far as I know, the standard way to install a new Debian instance from an existing Debian instance. Unlike our VM installs above, debootstrap creates a “chroot” directory, and what you do with that directory is then up to you. Usually you would debootstrap into some mounted device. debootstrap is very simple to use and driven completely from the command line.

It’s not particularly fast. Because it downloads, unpacks and installs each package, it can take an hour or more to run.

ubuntu-vm-builder

This is Ubuntu’s wrapper around debootstrap and libvirt/qemu.

cobbler

Cobbler is a network install server which lets you pxeboot and configure a network of machines (and virtual machines) from a central server. It has lots of wonderful features — go and read the web site.

Leave a comment

Filed under Uncategorized

Prebuilt distributions part 2

In part 1 I discussed how these days Linux Live CDs usually come with a prebuilt disk image of the distro which is simply copied over to the hard disk during installation. (The “old” method was to rpm/dpkg-install the packages which is much more time-consuming). However my first test wasn’t very successful because I was using the “cp” command to copy files.

Anaconda (the Fedora installer) is smarter than this. It “dd”s the prebuilt disk image to the hard disk and then uses an ext2/3/4 utility called resize2fs to expand it to the correct size.

I changed the previous guestfish script to take this approach.

The new/Anaconda approach is much faster. Our total time is down from over 18 minutes to 2½ minutes (approximately 2 minutes for the “dd”, 2 seconds for the resize2fs, and the rest of the time taken doing the partitioning and LVM creation).

Unfortunately we have to leave Ubuntu behind at this point. Ubuntu ships with a squashfs, and I’m not aware of any way to turn this into an ext3 partition efficiently (except to use “cp” which we showed in part 1 was very slow). The new script only works with Fedora Live CD ISOs.

The new script is after the cut.

Continue reading

1 Comment

Filed under Uncategorized

Prebuilt distributions part 1

Previously I took a look at unpacking Fedora and Ubuntu live CDs to find out what’s inside them and to ask the question can we use the prebuilt filesystem image that these live CDs contain to quickly create a Fedora or Ubuntu “all-defaults” virtual machine?

This is my first attempt, and it’s not successful, but it does demonstrate a large and interesting guestfish script doing a non-trivial amount of work.

This script:

  1. mounts the prebuilt filesystem from either a Fedora or Ubuntu live CD
  2. creates a disk image with a 200 MB /boot partition and a single / (root) logical volume covering the remainder of the disk
  3. uses the cp -a command to recursively copy the prebuilt filesystem to the disk

Where it fails is that “cp” isn’t very fast. On my local machine it took 18 minutes to copy all the files across, which means this isn’t a practical “instant install” method. (I didn’t in the end try to boot the final disk image).

In part 2 this week, I’ll look at the approach that anaconda takes: It dd’s the disk image and then runs resize2fs on it to expand it into the available space.

In part 3 I’ll compare this approach to others: virt-install, manual installation, kickstart, cobbler, debootstrap and ubuntu-vm-builder.

The script itself follows after the cut:

Continue reading

2 Comments

Filed under Uncategorized

Looking closer at Fedora, Ubuntu live CDs

Previously I’ve shown you can use guestfish to unpack a Fedora live CD.

I’m interested in whether we can use the contents of these live CDs to mass-install operating systems using libguestfs.

If you imagine that you go through an “all defaults” install of say Fedora or Ubuntu to a new virtual machine, then when you end up with is an identical disk image containing 1-2 GB of default packages and a lot of empty space. Two people asked to go through the same all-defaults install of the same distro would end up with roughly the same content. The details on the disk would be slightly different because some parts of the disk partitioning and ext3 superblocks change slightly depending on the overall disk size. But really those things can be fixed up afterwards using a little repartitioning, lvresize and resize2fs.

Let’s look inside an Ubuntu live CD:

$ guestfish --ro -a ubuntu-9.10-desktop-amd64.iso

Welcome to guestfish, the libguestfs filesystem interactive shell for
editing virtual machine filesystems.

Type: 'help' for help with commands
      'quit' to quit the shell

><fs> run
><fs> list-devices
/dev/sda
><fs> file /dev/sda
ISO 9660 CD-ROM filesystem data 'Ubuntu 9.10 amd64
><fs> mkmountpoint /t1
><fs> mount /dev/sda /t1
><fs> ll /t1/casper
total 691049
dr-xr-xr-x  2 root root      2048 Oct 27 14:31 .
dr-xr-xr-x 10 root root      2048 Oct 27 14:31 ..
-r--r--r--  2 root root     37288 Oct 27 14:19 filesystem.manifest
-r--r--r--  2 root root     35354 Oct 27 14:16 filesystem.manifest-desktop
-r--r--r--  2 root root 697778176 Oct 27 14:25 filesystem.squashfs
-r--r--r--  2 root root   5836401 Oct 27 14:20 initrd.lz
-r--r--r--  2 root root   3941696 Oct 16 12:12 vmlinuz
><fs> mkmountpoint /t2
><fs> mount-loop /t1/casper/filesystem.squashfs /t2
><fs> cat /t2/etc/debian_version
squeeze/sid

The file /casper/filesystem.squashfs seems to be a complete Ubuntu installation, and if I’m understanding this correctly the Ubuntu installer will copy this to the newly created filesystem directly. That will be the new Ubuntu installation, plus or minus some config file changes and some extra packages downloaded afterwards from the net.

Here’s the same examination of the Fedora 12 Live CD:

$ guestfish --ro -a Fedora-12-x86_64-Live.iso

Welcome to guestfish, the libguestfs filesystem interactive shell for
editing virtual machine filesystems.

Type: 'help' for help with commands
      'quit' to quit the shell

><fs> run
><fs> list-devices
/dev/sda
><fs> file /dev/sda
ISO 9660 CD-ROM filesystem data 'Fedora-12-x86_64-Live
><fs> mkmountpoint /t1
><fs> mount /dev/sda /t1
><fs> ls /t1
EFI
GPL
LiveOS
isolinux
><fs> ll /t1/LiveOS
total 655291
dr-xr-xr-x 2 root root      2048 Nov  9 14:45 .
dr-xr-xr-x 5 root root      2048 Nov  9 14:44 ..
-r-xr-xr-x 1 root root     23040 Nov  9 14:44 livecd-iso-to-disk
-r-xr-xr-x 1 root root      8192 Nov  9 14:45 osmin.img
-r-xr-xr-x 1 root root 670982144 Nov  9 14:48 squashfs.img
><fs> mkmountpoint /t2
><fs> mount-loop /t1/LiveOS/squashfs.img /t2
><fs> ls /t2
LiveOS
><fs> ls /t2/LiveOS/
ext3fs.img
><fs> mkmountpoint /t3
><fs> mount-loop /t2/LiveOS/ext3fs.img /t3
><fs> cat /t3/etc/redhat-release
Fedora release 12 (Constantine)

Again I hope I assume correctly that the installer copies ext3fs.img to the hard disk when installing Fedora 12.

So my vague plan, assuming anything I’ve written above is correct, is to take these pre-made filesystem images and allow people to quickly install specific operating system images from a simple tool:

$ virt-press Fedora-12 F12

which would stamp out a Fedora 12 VM in a few seconds and register it with libvirt as “F12″.

I’m not sure this is possible yet …

3 Comments

Filed under Uncategorized

Poor man’s P2V

(P2V = physical to virtual, taking a physical machine and converting it into a virtual machine)

What happens when you have an old server sitting in the corner — the hardware is flaky and you need to set up a virtual equivalent ASAP, but no one can remember how that old server is configured? People will sell you very expensive software to solve this problem for you.

But if you have some time and patience you can do P2V conversions by hand for free, and it’s not too hard. Here’s how.

First of all, grab a bootable Linux rescue CD. A Fedora CD in rescue mode will do just fine, but choose any Linux CD that you’re happy with.

Now you boot your machine from the CD, so that we are in a modern, Linux-based OS. From the Linux command line you will see the physical disks in the machine like /dev/sda or /dev/hda (check /sys/block).

All you do is take each physical disk in turn and copy it complete over to your virtualization host. Just do:

dd if=/dev/sda | ssh root@virthost 'cat > /var/lib/libvirt/images/guest.img'

That makes a block-for-block identical copy of the hard disk, and it usually takes several minutes to an hour to copy everything across, depending how fast the old server and the network is.

Now over to your virtualization host, how do you boot this?

With very recent versions of virt-install there is a virt-install --import option that you can use to import disk images directly.

Alternately, write a libvirt XML configuration file for the virtual machine. It’s usually best to start off with an existing XML configuration, so just pick another guest at random and do virsh dumpxml foo. Take that output, modify it suitably, make sure it’s full virt (“hvm”), and boot using:

virsh define guest.xml

Now at this point it may not in fact boot. You might need to edit a few things inside the virtual machine disk image, typically /etc/fstab, maybe install a new kernel, perhaps edit the network configuration.

Step forward: guestfish and virt-edit.

$ guestfish -i guest.img
$ virt-edit guest.img /etc/fstab

(Note: I am the author of virt-p2v which is currently in a big version 2.0 rewrite).

15 Comments

Filed under Uncategorized

Unpack the “Russian doll” of a F11 live CD

Fedora 11 live CDs are like Russian Matryoshka dolls – a filesystem within a filesystem within a filesystem.

On the outside they have to be in the standard CD ISO format because that’s what CDs require. However the CD ISO format is pretty useless, slow, limited filename length, and no support for SELinux labelling. So …

Inside the ISO is another filesystem, a Linux squashfs. (Question: why do they use the squashfs?) That’s not the end though, because …

Inside the squashfs is the final ext3 filesystem as a blob.

In libguestfs / guestfish 1.0.62+ I’ve added some commands to make it easy to unpack this, so you can read out the contents of the inner ext3 filesystem.

All without needing to be root, of course.

Here’s how:

$ guestfish -a Fedora-11-i686-Live.iso

Welcome to guestfish, the libguestfs filesystem interactive shell for
editing virtual machine filesystems.

Type: 'help' for help with commands
      'quit' to quit the shell


><fs> mkmountpoint /cd
><fs> mkmountpoint /squash
><fs> mount /dev/sda /cd
><fs> mount-loop /cd/LiveOS/squashfs.img /squash
><fs> ls /squash/
LiveOS
><fs> ls /squash/LiveOS/
ext3fs.img
><fs> mkmountpoint /ext3
><fs> mount-loop /squash/LiveOS/ext3fs.img /ext3
><fs> ls /ext3/
.readahead_collect
bin
boot
dev
etc
home
[...]

After this, the inner ext3 filesystem is mounted inside guestfish as /ext3 and you can go ahead and read out files from it. (But not, unfortunately, edit it because ISO images are read-only. See my earlier posting about that).

2 Comments

Filed under Uncategorized