3 # Copyright (C) 2009 Red Hat Inc.
5 # This program is free software; you can redistribute it and/or modify
6 # it under the terms of the GNU General Public License as published by
7 # the Free Software Foundation; either version 2 of the License, or
8 # (at your option) any later version.
10 # This program is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 # GNU General Public License for more details.
15 # You should have received a copy of the GNU General Public License
16 # along with this program; if not, write to the Free Software
17 # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 use File::Temp qw/tempdir/;
29 eval "use Sys::Virt;";
30 eval "use XML::XPath;";
31 eval "use XML::XPath::XMLParser;";
37 virt-inspector - Display OS version, kernel, drivers, mount points, applications, etc. in a virtual machine
41 virt-inspector [--connect URI] domname
43 virt-inspector guest.img [guest.img ...]
47 B<virt-inspector> examines a virtual machine and tries to determine
48 the version of the OS, the kernel version, what drivers are installed,
49 whether the virtual machine is fully virtualized (FV) or
50 para-virtualized (PV), what applications are installed and more.
52 Virt-inspector can produce output in several formats, including a
53 readable text report, and XML for feeding into other programs.
55 Virt-inspector should only be run on I<inactive> virtual machines.
56 The program tries to determine that the machine is inactive and will
57 refuse to run if it thinks you are trying to inspect a running domain.
59 In the normal usage, use C<virt-inspector domname> where C<domname> is
60 the libvirt domain (see: C<virsh list --all>).
62 You can also run virt-inspector directly on disk images from a single
63 virtual machine. Use C<virt-inspector guest.img>. In rare cases a
64 domain has several block devices, in which case you should list them
65 one after another, with the first corresponding to the guest's
66 C</dev/sda>, the second to the guest's C</dev/sdb> and so on.
68 Virt-inspector can only inspect and report upon I<one domain at a
69 time>. To inspect several virtual machines, you have to run
70 virt-inspector several times (for example, from a shell script
73 Because virt-inspector needs direct access to guest images, it won't
74 normally work over remote libvirt connections.
92 =item B<--connect URI> | B<-c URI>
94 If using libvirt, connect to the given I<URI>. If omitted,
95 then we connect to the default libvirt hypervisor.
97 Libvirt is only used if you specify a C<domname> on the
98 command line. If you specify guest block devices directly,
99 then libvirt is not used at all.
107 Force reading a particular guest even if it appears to be active. In
108 earlier versions of virt-inspector, this could be dangerous (for
109 example, corrupting the guest's disk image). However in more recent
110 versions, it should not cause corruption, but might cause
111 virt-inspector to crash or produce incorrect results.
119 The following options select the output format. Use only one of them.
120 The default is a readable text report.
124 =item B<--text> (default)
130 Produce no output at all.
134 If you select I<--xml> then you get XML output which can be fed
139 If you select I<--perl> then you get Perl structures output which
140 can be used directly in another Perl program.
146 If you select I<--fish> then we print a L<guestfish(1)> command
147 line which will automatically mount up the filesystems on the
148 correct mount points. Try this for example:
150 guestfish $(virt-inspector --fish guest.img)
152 I<--ro-fish> is the same, but the I<--ro> option is passed to
153 guestfish so that the filesystems are mounted read-only.
157 In "query mode" we answer common questions about the guest, such
158 as whether it is fullvirt or needs a Xen hypervisor to run.
160 See section I<QUERY MODE> below.
164 my $windows_registry;
166 =item B<--windows-registry>
168 If this item is passed, I<and> the guest is Windows, I<and> the
169 external program C<reged> is available (see SEE ALSO section), then we
170 attempt to parse the Windows registry. This allows much more
171 information to be gathered for Windows guests.
173 This is quite an expensive and slow operation, so we don't do it by
180 GetOptions ("help|?" => \$help,
181 "connect|c=s" => \$uri,
183 "text" => sub { $output = "text" },
184 "none" => sub { $output = "none" },
185 "xml" => sub { $output = "xml" },
186 "perl" => sub { $output = "perl" },
187 "fish" => sub { $output = "fish" },
188 "guestfish" => sub { $output = "fish" },
189 "ro-fish" => sub { $output = "ro-fish" },
190 "ro-guestfish" => sub { $output = "ro-fish" },
191 "query" => sub { $output = "query" },
192 "windows-registry" => \$windows_registry,
194 pod2usage (1) if $help;
195 pod2usage ("$0: no image or VM names given") if @ARGV == 0;
197 # Domain name or guest image(s)?
205 die "guest image $_ does not exist or is not readable\n"
209 die "no libvirt support (install Sys::Virt)"
210 unless exists $INC{"Sys/Virt.pm"};
212 pod2usage ("$0: too many domains listed on command line") if @ARGV > 1;
216 $vmm = Sys::Virt->new (uri => $uri, readonly => 1);
218 $vmm = Sys::Virt->new (readonly => 1);
220 die "cannot connect to libvirt $uri\n" unless $vmm;
222 my @doms = $vmm->list_defined_domains ();
225 if ($_->get_name () eq $ARGV[0]) {
230 die "$ARGV[0] is not the name of an inactive libvirt domain\n"
233 # Get the names of the image(s).
234 my $xml = $dom->get_xml_description ();
236 my $p = XML::XPath->new (xml => $xml);
237 my @disks = $p->findnodes ('//devices/disk/source/@dev');
238 @images = map { $_->getData } @disks;
241 # We've now got the list of @images, so feed them to libguestfs.
242 my $g = Sys::Guestfs->new ();
243 $g->add_drive_ro ($_) foreach @images;
247 # We want to get the list of LVs and partitions (ie. anything that
248 # could contain a filesystem). Discard any partitions which are PVs.
249 my @partitions = $g->list_partitions ();
250 my @pvs = $g->pvs ();
254 return 1 if $_ eq $t;
258 @partitions = grep { ! is_pv ($_) } @partitions;
260 my @lvs = $g->lvs ();
266 Linux (distro + version)
270 +--- Filesystems ---------- Installed apps --- Kernel & drivers
271 ----------- -------------- ----------------
272 mount point => device List of apps Extra information
273 mount point => device and versions about kernel(s)
276 (plus lots of extra information
277 about each filesystem)
279 The output of virt-inspector is a complex two-level data structure.
281 At the top level is a list of the operating systems installed on the
282 guest. (For the vast majority of guests, only a single OS is
283 installed.) The data returned for the OS includes the name (Linux,
284 Windows), the distribution and version.
286 The diagram above shows what we return for each OS.
288 With the I<--xml> option the output is mapped into an XML document.
289 Unfortunately there is no clear schema for this document
290 (contributions welcome) but you can get an idea of the format by
291 looking at other documents and as a last resort the source for this
294 With the I<--fish> or I<--ro-fish> option the mount points are mapped to
295 L<guestfish(1)> command line parameters, so that you can go in
296 afterwards and inspect the guest with everything mounted in the
297 right place. For example:
299 guestfish $(virt-inspector --ro-fish guest.img)
300 ==> guestfish --ro -a guest.img -m /dev/VG/LV:/ -m /dev/sda1:/boot
304 # List of possible filesystems.
305 my @devices = sort (@lvs, @partitions);
307 # Now query each one to build up a picture of what's in it.
308 my %fses = map { $_ => check_fs ($_) } @devices;
310 # Now the complex checking code itself.
311 # check_fs takes a device name (LV or partition name) and returns
312 # a hashref containing everything we can find out about the device.
315 my $dev = shift; # LV or partition name.
317 my %r; # Result hash.
319 # First try 'file(1)' on it.
320 my $file = $g->file ($dev);
321 if ($file =~ /ext2 filesystem data/) {
324 } elsif ($file =~ /ext3 filesystem data/) {
327 } elsif ($file =~ /ext4 filesystem data/) {
330 } elsif ($file =~ m{Linux/i386 swap file}) {
336 # If it's ext2/3/4, then we want the UUID and label.
337 if (exists $r{fstype} && $r{fstype} =~ /^ext/) {
338 $r{uuid} = $g->get_e2uuid ($dev);
339 $r{label} = $g->get_e2label ($dev);
342 # Try mounting it, fnarrr.
344 $r{is_mountable} = 1;
345 eval { $g->mount_ro ($dev, "/") };
347 # It's not mountable, probably empty or some format
348 # we don't understand.
349 $r{is_mountable} = 0;
354 if ($g->is_file ("/grub/menu.lst") ||
355 $g->is_file ("/grub/grub.conf")) {
356 $r{content} = "linux-grub";
362 if ($g->is_dir ("/etc") && $g->is_dir ("/bin") &&
363 $g->is_file ("/etc/fstab")) {
364 $r{content} = "linux-root";
366 check_linux_root (\%r);
371 if ($g->is_dir ("/etc") && $g->is_dir ("/bin") &&
372 $g->is_dir ("/share") && !$g->exists ("/local") &&
373 !$g->is_file ("/etc/fstab")) {
374 $r{content} = "linux-usrlocal";
379 if ($g->is_dir ("/etc") && $g->is_dir ("/bin") &&
380 $g->is_dir ("/share") && $g->exists ("/local") &&
381 !$g->is_file ("/etc/fstab")) {
382 $r{content} = "linux-usr";
387 if ($g->is_file ("/AUTOEXEC.BAT") ||
388 $g->is_file ("/autoexec.bat") ||
389 $g->is_dir ("/Program Files") ||
390 $g->is_dir ("/WINDOWS") ||
391 $g->is_file ("/boot.ini") ||
392 $g->is_file ("/ntldr")) {
393 $r{fstype} = "ntfs"; # XXX this is a guess
394 $r{fsos} = "windows";
395 $r{content} = "windows-root";
397 check_windows_root (\%r);
412 # Look into /etc to see if we recognise the operating system.
413 if ($g->is_file ("/etc/redhat-release")) {
414 $_ = $g->cat ("/etc/redhat-release");
415 if (/Fedora release (\d+\.\d+)/) {
416 $r->{osdistro} = "fedora";
417 $r->{osversion} = "$1"
418 } elsif (/(Red Hat Enterprise Linux|CentOS|Scientific Linux).*release (\d+).*Update (\d+)/) {
419 $r->{osdistro} = "redhat";
420 $r->{osversion} = "$2.$3";
421 } elsif (/(Red Hat Enterprise Linux|CentOS|Scientific Linux).*release (\d+(?:\.(\d+))?)/) {
422 $r->{osdistro} = "redhat";
423 $r->{osversion} = "$2";
425 $r->{osdistro} = "redhat";
427 } elsif ($g->is_file ("/etc/debian_version")) {
428 $_ = $g->cat ("/etc/debian_version");
430 $r->{osdistro} = "debian";
431 $r->{osversion} = "$1";
433 $r->{osdistro} = "debian";
437 # Parse the contents of /etc/fstab. This is pretty vital so
438 # we can determine where filesystems are supposed to be mounted.
439 eval "\$_ = \$g->cat ('/etc/fstab');";
441 my @lines = split /\n/;
444 my @fields = split /[ \t]+/;
446 my $spec = $fields[0]; # first column (dev/label/uuid)
447 my $file = $fields[1]; # second column (mountpoint)
448 if ($spec =~ m{^/} ||
449 $spec =~ m{^LABEL=} ||
450 $spec =~ m{^UUID=} ||
452 push @fstab, [$spec, $file]
456 $r->{fstab} = \@fstab if @fstab;
460 # We only support NT. The control file /boot.ini contains a list of
461 # Windows installations and their %systemroot%s in a simple text
464 # XXX We could parse this better. This won't work if /boot.ini is on
465 # a different drive from the %systemroot%, and in other unusual cases.
467 sub check_windows_root
472 my $boot_ini = resolve_windows_path ("/", "boot.ini");
473 $r->{boot_ini} = $boot_ini;
475 if (defined $r->{boot_ini}) {
476 $_ = $g->cat ($boot_ini);
477 my @lines = split /\n/;
483 } elsif (m/^default=.*?\\(\w+)$/i) {
486 } elsif (m/\\(\w+)=/) {
492 if (defined $systemroot) {
493 $r->{systemroot} = resolve_windows_path ("/", $systemroot);
494 if (defined $r->{systemroot} && $windows_registry) {
495 check_windows_registry ($r, $r->{systemroot});
501 sub check_windows_registry
505 my $systemroot = shift;
507 # Download the system registry files. Only download the
508 # interesting ones, and we don't bother with user profiles at all.
509 my $system32 = resolve_windows_path ($systemroot, "system32");
510 if (defined $system32) {
511 my $config = resolve_windows_path ($system32, "config");
512 if (defined $config) {
513 my $software = resolve_windows_path ($config, "software");
514 if (defined $software) {
515 load_windows_registry ($r, $software,
516 "HKEY_LOCAL_MACHINE\\SOFTWARE");
518 my $system = resolve_windows_path ($config, "system");
519 if (defined $system) {
520 load_windows_registry ($r, $system,
521 "HKEY_LOCAL_MACHINE\\System");
527 sub load_windows_registry
534 my $dir = tempdir (CLEANUP => 1);
536 $g->download ($regfile, "$dir/reg");
538 # 'reged' command is particularly noisy. Redirect stdout and
539 # stderr to /dev/null temporarily.
540 open SAVEOUT, ">&STDOUT";
541 open SAVEERR, ">&STDERR";
542 open STDOUT, ">/dev/null";
543 open STDERR, ">/dev/null";
545 my @cmd = ("reged", "-x", "$dir/reg", "$prefix", "\\", "$dir/out");
546 my $res = system (@cmd);
550 open STDOUT, ">&SAVEOUT";
551 open STDERR, ">&SAVEERR";
556 warn "reged command failed: $?";
560 # Some versions of reged segfault on inputs. If that happens we
561 # may get no / partial output file. Anyway, if it exists, load
564 unless (open F, "$dir/out") {
565 warn "no output from reged command: $!";
568 { local $/ = undef; $content = <F>; }
572 @registry = @{$r->{registry}} if exists $r->{registry};
573 push @registry, $content;
574 $r->{registry} = \@registry;
577 # Because of case sensitivity, the actual path might have a different
578 # name, and ntfs-3g is always case sensitive. Find out what the real
579 # path is. Returns the correct full path, or undef.
580 sub resolve_windows_path
583 my $parent = shift; # Must exist, with correct case.
586 foreach ($g->ls ($parent)) {
587 if (lc ($_) eq lc ($dir)) {
588 if ($parent eq "/") {
604 # Grub version, if we care.
607 #print Dumper (\%fses);
609 #----------------------------------------------------------------------
610 # Now find out how many operating systems we've got. Usually just one.
614 foreach (sort keys %fses) {
615 if ($fses{$_}->{is_root}) {
620 get_os_version (\%r);
621 assign_mount_points (\%r);
631 $r->{os} = $r->{root}->{fsos} if exists $r->{root}->{fsos};
632 $r->{distro} = $r->{root}->{osdistro} if exists $r->{root}->{osdistro};
633 $r->{version} = $r->{root}->{osversion} if exists $r->{root}->{osversion};
636 sub assign_mount_points
641 $r->{mounts} = { "/" => $r->{root_device} };
642 $r->{filesystems} = { $r->{root_device} => $r->{root} };
644 # Use /etc/fstab if we have it to mount the rest.
645 if (exists $r->{root}->{fstab}) {
646 my @fstab = @{$r->{root}->{fstab}};
648 my ($spec, $file) = @$_;
650 my ($dev, $fs) = find_filesystem ($spec);
652 $r->{mounts}->{$file} = $dev;
653 $r->{filesystems}->{$dev} = $fs;
654 if (exists $fs->{used}) {
664 # Find filesystem by device name, LABEL=.. or UUID=..
671 foreach (sort keys %fses) {
672 if (exists $fses{$_}->{label} &&
673 $fses{$_}->{label} eq $label) {
674 return ($_, $fses{$_});
677 warn "unknown filesystem label $label\n";
679 } elsif (/^UUID=(.*)/) {
681 foreach (sort keys %fses) {
682 if (exists $fses{$_}->{uuid} &&
683 $fses{$_}->{uuid} eq $uuid) {
684 return ($_, $fses{$_});
687 warn "unknown filesystem UUID $uuid\n";
690 return ($_, $fses{$_}) if exists $fses{$_};
692 if (m{^/dev/hd(.*)} && exists $fses{"/dev/sd$1"}) {
693 return ("/dev/sd$1", $fses{"/dev/sd$1"});
695 if (m{^/dev/xvd(.*)} && exists $fses{"/dev/sd$1"}) {
696 return ("/dev/sd$1", $fses{"/dev/sd$1"});
699 return () if m{/dev/cdrom};
701 warn "unknown filesystem $_\n";
706 #print Dumper(\%oses);
708 #----------------------------------------------------------------------
709 # Mount up the disks so we can check for applications
710 # and kernels. Skip this if the output is "*fish" because
711 # we don't need to know.
713 if ($output !~ /.*fish$/) {
714 # Temporary directory for use by check_for_initrd.
715 my $dir = tempdir (CLEANUP => 1);
718 foreach $root_dev (sort keys %oses) {
719 my $mounts = $oses{$root_dev}->{mounts};
720 # Have to mount / first. Luckily '/' is early in the ASCII
721 # character set, so this should be OK.
722 foreach (sort keys %$mounts) {
723 $g->mount_ro ($mounts->{$_}, $_)
724 if $_ ne "swap" && ($_ eq '/' || $g->is_dir ($_));
727 check_for_applications ($root_dev);
728 check_for_kernels ($root_dev);
729 if ($oses{$root_dev}->{os} eq "linux") {
730 check_for_modprobe_aliases ($root_dev);
731 check_for_initrd ($root_dev, $dir);
738 sub check_for_applications
741 my $root_dev = shift;
745 my $os = $oses{$root_dev}->{os};
746 if ($os eq "linux") {
747 my $distro = $oses{$root_dev}->{distro};
748 if (defined $distro && ($distro eq "redhat" || $distro eq "fedora")) {
749 my @lines = $g->command_lines
752 "--qf", "%{name} %{epoch} %{version} %{release} %{arch}\n"]);
754 if (m/^(.*) (.*) (.*) (.*) (.*)$/) {
756 $epoch = "" if $epoch eq "(none)";
768 } elsif ($os eq "windows") {
770 # I worked out a general plan for this, but haven't
771 # implemented it yet. We can iterate over /Program Files
772 # looking for *.EXE files, which we download, then use
773 # i686-pc-mingw32-windres on, to find the VERSIONINFO
774 # section, which has a lot of useful information.
777 $oses{$root_dev}->{apps} = \@apps;
780 sub check_for_kernels
783 my $root_dev = shift;
787 my $os = $oses{$root_dev}->{os};
788 if ($os eq "linux") {
789 # Installed kernels will have a corresponding /lib/modules/<version>
790 # directory, which is the easiest way to find out what kernels
791 # are installed, and what modules are available.
792 foreach ($g->ls ("/lib/modules")) {
793 if ($g->is_dir ("/lib/modules/$_")) {
795 $kernel{version} = $_;
799 foreach ($g->find ("/lib/modules/$_")) {
800 if (m,/([^/]+)\.ko$, || m,([^/]+)\.o$,) {
805 $kernel{modules} = \@modules;
807 push @kernels, \%kernel;
811 } elsif ($os eq "windows") {
815 $oses{$root_dev}->{kernels} = \@kernels;
818 # Check /etc/modprobe.conf to see if there are any specified
819 # drivers associated with network (ethX) or hard drives. Normally
820 # one might find something like:
823 # alias scsi_hostadapter xenblk
825 # XXX This doesn't look beyond /etc/modprobe.conf, eg. in /etc/modprobe.d/
827 sub check_for_modprobe_aliases
830 my $root_dev = shift;
833 eval { @lines = $g->read_lines ("/etc/modprobe.conf"); };
834 return if $@ || !@lines;
836 my %modprobe_aliases;
839 $modprobe_aliases{$1} = $2 if /^\s*alias\s+(\S+)\s+(\S+)/;
842 $oses{$root_dev}->{modprobe_aliases} = \%modprobe_aliases;
845 # Get a listing of device drivers in any initrd corresponding to a
846 # kernel. This is an indication of what can possibly be booted.
851 my $root_dev = shift;
856 foreach my $initrd ($g->ls ("/boot")) {
857 if ($initrd =~ m/^initrd-(.*)\.img$/ && $g->is_file ("/boot/$initrd")) {
860 # We have to download these to a temporary file.
861 $g->download ("/boot/$initrd", "$dir/initrd");
863 my $cmd = "zcat $dir/initrd | file -";
864 open P, "$cmd |" or die "$cmd: $!";
866 { local $/ = undef; $lines = <P>; }
868 if ($lines =~ /ext\d filesystem data/) {
869 # Before initramfs came along, these were compressed
870 # ext2 filesystems. We could run another libguestfs
871 # instance to unpack these, but punt on them for now. (XXX)
872 warn "initrd image is unsupported ext2/3/4 filesystem\n";
874 elsif ($lines =~ /cpio/) {
875 my $cmd = "zcat $dir/initrd | cpio --quiet -it";
876 open P, "$cmd |" or die "$cmd: $!";
879 if m,([^/]+)\.ko$, || m,([^/]+)\.o$,;
882 unlink "$dir/initrd";
883 $initrd_modules{$version} = \@modules;
887 warn "unrecognized initrd image: $lines\n";
892 $oses{$root_dev}->{initrd_modules} = \%initrd_modules;
895 #----------------------------------------------------------------------
898 if ($output eq "fish" || $output eq "ro-fish") {
899 my @osdevs = keys %oses;
900 # This only works if there is a single OS.
901 die "--fish output is only possible with a single OS\n" if @osdevs != 1;
903 my $root_dev = $osdevs[0];
905 if ($output eq "ro-fish") {
909 print "-a $_ " foreach @images;
911 my $mounts = $oses{$root_dev}->{mounts};
912 # Have to mount / first. Luckily '/' is early in the ASCII
913 # character set, so this should be OK.
914 foreach (sort keys %$mounts) {
915 print "-m $mounts->{$_}:$_ " if $_ ne "swap";
921 elsif ($output eq "perl") {
922 print Dumper(\%oses);
925 # Plain text output (the default).
926 elsif ($output eq "text") {
931 elsif ($output eq "xml") {
936 elsif ($output eq "query") {
942 output_text_os ($oses{$_}) foreach sort keys %oses;
949 print $os->{os}, " " if exists $os->{os};
950 print $os->{distro}, " " if exists $os->{distro};
951 print $os->{version}, " " if exists $os->{version};
952 print "on ", $os->{root_device}, ":\n";
954 print " Mountpoints:\n";
955 my $mounts = $os->{mounts};
956 foreach (sort keys %$mounts) {
957 printf " %-30s %s\n", $mounts->{$_}, $_
960 print " Filesystems:\n";
961 my $filesystems = $os->{filesystems};
962 foreach (sort keys %$filesystems) {
964 print " label: $filesystems->{$_}{label}\n"
965 if exists $filesystems->{$_}{label};
966 print " UUID: $filesystems->{$_}{uuid}\n"
967 if exists $filesystems->{$_}{uuid};
968 print " type: $filesystems->{$_}{fstype}\n"
969 if exists $filesystems->{$_}{fstype};
970 print " content: $filesystems->{$_}{content}\n"
971 if exists $filesystems->{$_}{content};
974 if (exists $os->{modprobe_aliases}) {
975 my %aliases = %{$os->{modprobe_aliases}};
976 my @keys = sort keys %aliases;
978 print " Modprobe aliases:\n";
980 printf " %-30s %s\n", $_, $aliases{$_}
985 if (exists $os->{initrd_modules}) {
986 my %modvers = %{$os->{initrd_modules}};
987 my @keys = sort keys %modvers;
989 print " Initrd modules:\n";
991 my @modules = @{$modvers{$_}};
993 print " $_\n" foreach @modules;
998 print " Applications:\n";
999 my @apps = @{$os->{apps}};
1001 print " $_->{name} $_->{version}\n"
1004 print " Kernels:\n";
1005 my @kernels = @{$os->{kernels}};
1006 foreach (@kernels) {
1007 print " $_->{version}\n";
1008 my @modules = @{$_->{modules}};
1009 foreach (@modules) {
1014 if (exists $os->{root}->{registry}) {
1015 print " Windows Registry entries:\n";
1016 # These are just lumps of text - dump them out.
1017 foreach (@{$os->{root}->{registry}}) {
1025 print "<operatingsystems>\n";
1026 output_xml_os ($oses{$_}) foreach sort keys %oses;
1027 print "</operatingsystems>\n";
1034 print "<operatingsystem>\n";
1036 print "<os>", $os->{os}, "</os>\n" if exists $os->{os};
1037 print "<distro>", $os->{distro}, "</distro>\n" if exists $os->{distro};
1038 print "<version>", $os->{version}, "</version>\n" if exists $os->{version};
1039 print "<root>", $os->{root_device}, "</root>\n";
1041 print "<mountpoints>\n";
1042 my $mounts = $os->{mounts};
1043 foreach (sort keys %$mounts) {
1044 printf "<mountpoint dev='%s'>%s</mountpoint>\n",
1047 print "</mountpoints>\n";
1049 print "<filesystems>\n";
1050 my $filesystems = $os->{filesystems};
1051 foreach (sort keys %$filesystems) {
1052 print "<filesystem dev='$_'>\n";
1053 print "<label>$filesystems->{$_}{label}</label>\n"
1054 if exists $filesystems->{$_}{label};
1055 print "<uuid>$filesystems->{$_}{uuid}</uuid>\n"
1056 if exists $filesystems->{$_}{uuid};
1057 print "<type>$filesystems->{$_}{fstype}</type>\n"
1058 if exists $filesystems->{$_}{fstype};
1059 print "<content>$filesystems->{$_}{content}</content>\n"
1060 if exists $filesystems->{$_}{content};
1061 print "</filesystem>\n";
1063 print "</filesystems>\n";
1065 if (exists $os->{modprobe_aliases}) {
1066 my %aliases = %{$os->{modprobe_aliases}};
1067 my @keys = sort keys %aliases;
1069 print "<modprobealiases>\n";
1071 printf "<alias device=\"%s\">%s</alias>\n", $_, $aliases{$_}
1073 print "</modprobealiases>\n";
1077 if (exists $os->{initrd_modules}) {
1078 my %modvers = %{$os->{initrd_modules}};
1079 my @keys = sort keys %modvers;
1081 print "<initrds>\n";
1083 my @modules = @{$modvers{$_}};
1084 print "<initrd version=\"$_\">\n";
1085 print "<module>$_</module>\n" foreach @modules;
1086 print "</initrd>\n";
1088 print "</initrds>\n";
1092 print "<applications>\n";
1093 my @apps = @{$os->{apps}};
1095 print "<application>\n";
1096 print "<name>$_->{name}</name><version>$_->{version}</version>\n";
1097 print "</application>\n";
1099 print "</applications>\n";
1101 print "<kernels>\n";
1102 my @kernels = @{$os->{kernels}};
1103 foreach (@kernels) {
1105 print "<version>$_->{version}</version>\n";
1106 print "<modules>\n";
1107 my @modules = @{$_->{modules}};
1108 foreach (@modules) {
1109 print "<module>$_</module>\n";
1111 print "</modules>\n";
1112 print "</kernel>\n";
1114 print "</kernels>\n";
1116 if (exists $os->{root}->{registry}) {
1117 print "<windowsregistryentries>\n";
1118 # These are just lumps of text - dump them out.
1119 foreach (@{$os->{root}->{registry}}) {
1120 print "<windowsregistryentry>\n";
1121 print escape_xml($_), "\n";
1122 print "</windowsregistryentry>\n";
1124 print "</windowsregistryentries>\n";
1127 print "</operatingsystem>\n";
1142 When you use C<virt-inspector --query>, the output is a series of
1150 (each answer is usually C<yes> or C<no>, or the line is completely
1151 missing if we could not determine the answer at all).
1153 If the guest is multiboot, you can get apparently conflicting answers
1154 (eg. C<windows=yes> and C<linux=yes>, or a guest which is both
1155 fullvirt and has a Xen PV kernel). This is normal, and just means
1156 that the guest can do both things, although it might require operator
1157 intervention such as selecting a boot option when the guest is
1160 This section describes the full range of answers possible.
1168 output_query_windows ();
1169 output_query_linux ();
1170 output_query_rhel ();
1171 output_query_fedora ();
1172 output_query_debian ();
1173 output_query_fullvirt ();
1174 output_query_xen_domU_kernel ();
1175 output_query_xen_pv_drivers ();
1176 output_query_virtio_drivers ();
1179 =item windows=(yes|no)
1181 Answer C<yes> if Microsoft Windows is installed in the guest.
1185 sub output_query_windows
1188 foreach my $os (keys %oses) {
1189 $windows="yes" if $oses{$os}->{os} eq "windows";
1191 print "windows=$windows\n";
1194 =item linux=(yes|no)
1196 Answer C<yes> if a Linux kernel is installed in the guest.
1200 sub output_query_linux
1203 foreach my $os (keys %oses) {
1204 $linux="yes" if $oses{$os}->{os} eq "linux";
1206 print "linux=$linux\n";
1211 Answer C<yes> if the guest contains Red Hat Enterprise Linux.
1215 sub output_query_rhel
1218 foreach my $os (keys %oses) {
1219 $rhel="yes" if $oses{$os}->{os} eq "linux" && $oses{$os}->{distro} eq "redhat";
1221 print "rhel=$rhel\n";
1224 =item fedora=(yes|no)
1226 Answer C<yes> if the guest contains the Fedora Linux distribution.
1230 sub output_query_fedora
1233 foreach my $os (keys %oses) {
1234 $fedora="yes" if $oses{$os}->{os} eq "linux" && $oses{$os}->{distro} eq "fedora";
1236 print "fedora=$fedora\n";
1239 =item debian=(yes|no)
1241 Answer C<yes> if the guest contains the Debian Linux distribution.
1245 sub output_query_debian
1248 foreach my $os (keys %oses) {
1249 $debian="yes" if $oses{$os}->{os} eq "linux" && $oses{$os}->{distro} eq "debian";
1251 print "debian=$debian\n";
1254 =item fullvirt=(yes|no)
1256 Answer C<yes> if there is at least one operating system kernel
1257 installed in the guest which runs fully virtualized. Such a guest
1258 would require a hypervisor which supports full system virtualization.
1262 sub output_query_fullvirt
1264 # The assumption is full-virt, unless all installed kernels
1265 # are identified as paravirt.
1266 # XXX Fails on Windows guests.
1267 foreach my $os (keys %oses) {
1268 foreach my $kernel (@{$oses{$os}->{kernels}}) {
1269 my $is_pv = $kernel->{version} =~ m/xen/;
1271 print "fullvirt=yes\n";
1276 print "fullvirt=no\n";
1279 =item xen_domU_kernel=(yes|no)
1281 Answer C<yes> if there is at least one Linux kernel installed in
1282 the guest which is compiled as a Xen DomU (a Xen paravirtualized
1287 sub output_query_xen_domU_kernel
1289 foreach my $os (keys %oses) {
1290 foreach my $kernel (@{$oses{$os}->{kernels}}) {
1291 my $is_xen = $kernel->{version} =~ m/xen/;
1293 print "xen_domU_kernel=yes\n";
1298 print "xen_domU_kernel=no\n";
1301 =item xen_pv_drivers=(yes|no)
1303 Answer C<yes> if the guest has Xen paravirtualized drivers installed
1304 (usually the kernel itself will be fully virtualized, but the PV
1305 drivers have been installed by the administrator for performance
1310 sub output_query_xen_pv_drivers
1312 foreach my $os (keys %oses) {
1313 foreach my $kernel (@{$oses{$os}->{kernels}}) {
1314 foreach my $module (@{$kernel->{modules}}) {
1315 if ($module =~ m/xen-/) {
1316 print "xen_pv_drivers=yes\n";
1322 print "xen_pv_drivers=no\n";
1325 =item virtio_drivers=(yes|no)
1327 Answer C<yes> if the guest has virtio paravirtualized drivers
1328 installed. Virtio drivers are commonly used to improve the
1333 sub output_query_virtio_drivers
1335 foreach my $os (keys %oses) {
1336 foreach my $kernel (@{$oses{$os}->{kernels}}) {
1337 foreach my $module (@{$kernel->{modules}}) {
1338 if ($module =~ m/virtio_/) {
1339 print "virtio_drivers=yes\n";
1345 print "virtio_drivers=no\n";
1356 L<http://libguestfs.org/>.
1358 For Windows registry parsing we require the C<reged> program
1359 from L<http://home.eunet.no/~pnordahl/ntpasswd/>.
1363 Richard W.M. Jones L<http://et.redhat.com/~rjones/>
1367 Copyright (C) 2009 Red Hat Inc.
1369 This program is free software; you can redistribute it and/or modify
1370 it under the terms of the GNU General Public License as published by
1371 the Free Software Foundation; either version 2 of the License, or
1372 (at your option) any later version.
1374 This program is distributed in the hope that it will be useful,
1375 but WITHOUT ANY WARRANTY; without even the implied warranty of
1376 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1377 GNU General Public License for more details.
1379 You should have received a copy of the GNU General Public License
1380 along with this program; if not, write to the Free Software
1381 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.