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;";
35 virt-inspector - Display OS version, kernel, drivers, mount points, applications, etc. in a virtual machine
39 virt-inspector [--connect URI] domname
41 virt-inspector guest.img [guest.img ...]
45 B<virt-inspector> examines a virtual machine and tries to determine
46 the version of the OS, the kernel version, what drivers are installed,
47 whether the virtual machine is fully virtualized (FV) or
48 para-virtualized (PV), what applications are installed and more.
50 Virt-inspector can produce output in several formats, including a
51 readable text report, and XML for feeding into other programs.
53 Virt-inspector should only be run on I<inactive> virtual machines.
54 The program tries to determine that the machine is inactive and will
55 refuse to run if it thinks you are trying to inspect a running domain.
57 In the normal usage, use C<virt-inspector domname> where C<domname> is
58 the libvirt domain (see: C<virsh list --all>).
60 You can also run virt-inspector directly on disk images from a single
61 virtual machine. Use C<virt-inspector guest.img>. In rare cases a
62 domain has several block devices, in which case you should list them
63 one after another, with the first corresponding to the guest's
64 C</dev/sda>, the second to the guest's C</dev/sdb> and so on.
66 Virt-inspector can only inspect and report upon I<one domain at a
67 time>. To inspect several virtual machines, you have to run
68 virt-inspector several times (for example, from a shell script
71 Because virt-inspector needs direct access to guest images, it won't
72 normally work over remote libvirt connections.
90 =item B<--connect URI> | B<-c URI>
92 If using libvirt, connect to the given I<URI>. If omitted,
93 then we connect to the default libvirt hypervisor.
95 Libvirt is only used if you specify a C<domname> on the
96 command line. If you specify guest block devices directly,
97 then libvirt is not used at all.
105 Force reading a particular guest even if it appears to be active. In
106 earlier versions of virt-inspector, this could be dangerous (for
107 example, corrupting the guest's disk image). However in more recent
108 versions, it should not cause corruption, but might cause
109 virt-inspector to crash or produce incorrect results.
117 The following options select the output format. Use only one of them.
118 The default is a readable text report.
122 =item B<--text> (default)
128 Produce no output at all.
132 If you select I<--xml> then you get XML output which can be fed
137 If you select I<--perl> then you get Perl structures output which
138 can be used directly in another Perl program.
144 If you select I<--fish> then we print a L<guestfish(1)> command
145 line which will automatically mount up the filesystems on the
146 correct mount points. Try this for example:
148 eval `virt-inspector --fish guest.img`
150 I<--ro-fish> is the same, but the I<--ro> option is passed to
151 guestfish so that the filesystems are mounted read-only.
155 In "query mode" we answer common questions about the guest, such
156 as whether it is fullvirt or needs a Xen hypervisor to run.
158 See section I<QUERY MODE> below.
164 GetOptions ("help|?" => \$help,
165 "connect|c=s" => \$uri,
167 "text" => sub { $output = "text" },
168 "none" => sub { $output = "none" },
169 "xml" => sub { $output = "xml" },
170 "perl" => sub { $output = "perl" },
171 "fish" => sub { $output = "fish" },
172 "guestfish" => sub { $output = "fish" },
173 "ro-fish" => sub { $output = "ro-fish" },
174 "ro-guestfish" => sub { $output = "ro-fish" },
175 "query" => sub { $output = "query" },
177 pod2usage (1) if $help;
178 pod2usage ("$0: no image or VM names given") if @ARGV == 0;
180 # Domain name or guest image(s)?
188 die "guest image $_ does not exist or is not readable\n"
192 die "no libvirt support (install Sys::Virt)"
193 unless exists $INC{"Sys/Virt.pm"};
195 pod2usage ("$0: too many domains listed on command line") if @ARGV > 1;
199 $vmm = Sys::Virt->new (uri => $uri, readonly => 1);
201 $vmm = Sys::Virt->new (readonly => 1);
203 die "cannot connect to libvirt $uri\n" unless $vmm;
205 my @doms = $vmm->list_defined_domains ();
208 if ($_->get_name () eq $ARGV[0]) {
213 die "$ARGV[0] is not the name of an inactive libvirt domain\n"
216 # Get the names of the image(s).
217 my $xml = $dom->get_xml_description ();
219 my $p = new XML::XPath::XMLParser (xml => $xml);
220 my $disks = $p->find ("//devices/disk");
222 foreach ($disks->get_nodelist) {
223 print XML::XPath::XMLParser::as_string($_);
229 # We've now got the list of @images, so feed them to libguestfs.
230 my $g = Sys::Guestfs->new ();
231 $g->add_drive_ro ($_) foreach @images;
235 # We want to get the list of LVs and partitions (ie. anything that
236 # could contain a filesystem). Discard any partitions which are PVs.
237 my @partitions = $g->list_partitions ();
238 my @pvs = $g->pvs ();
242 return 1 if $_ eq $t;
246 @partitions = grep { ! is_pv ($_) } @partitions;
248 my @lvs = $g->lvs ();
254 Linux (distro + version)
258 +--- Filesystems ---------- Installed apps --- Kernel & drivers
259 ----------- -------------- ----------------
260 mount point => device List of apps Extra information
261 mount point => device and versions about kernel(s)
264 (plus lots of extra information
265 about each filesystem)
267 The output of virt-inspector is a complex two-level data structure.
269 At the top level is a list of the operating systems installed on the
270 guest. (For the vast majority of guests, only a single OS is
271 installed.) The data returned for the OS includes the name (Linux,
272 Windows), the distribution and version.
274 The diagram above shows what we return for each OS.
276 With the I<--xml> option the output is mapped into an XML document.
277 Unfortunately there is no clear schema for this document
278 (contributions welcome) but you can get an idea of the format by
279 looking at other documents and as a last resort the source for this
282 With the I<--fish> or I<--ro-fish> option the mount points are mapped to
283 L<guestfish(1)> command line parameters, so that you can go in
284 afterwards and inspect the guest with everything mounted in the
285 right place. For example:
287 eval `virt-inspector --ro-fish guest.img`
288 ==> guestfish --ro -a guest.img -m /dev/VG/LV:/ -m /dev/sda1:/boot
292 # List of possible filesystems.
293 my @devices = sort (@lvs, @partitions);
295 # Now query each one to build up a picture of what's in it.
296 my %fses = map { $_ => check_fs ($_) } @devices;
298 # Now the complex checking code itself.
299 # check_fs takes a device name (LV or partition name) and returns
300 # a hashref containing everything we can find out about the device.
303 my $dev = shift; # LV or partition name.
305 my %r; # Result hash.
307 # First try 'file(1)' on it.
308 my $file = $g->file ($dev);
309 if ($file =~ /ext2 filesystem data/) {
312 } elsif ($file =~ /ext3 filesystem data/) {
315 } elsif ($file =~ /ext4 filesystem data/) {
318 } elsif ($file =~ m{Linux/i386 swap file}) {
324 # If it's ext2/3/4, then we want the UUID and label.
325 if (exists $r{fstype} && $r{fstype} =~ /^ext/) {
326 $r{uuid} = $g->get_e2uuid ($dev);
327 $r{label} = $g->get_e2label ($dev);
330 # Try mounting it, fnarrr.
332 $r{is_mountable} = 1;
333 eval { $g->mount_ro ($dev, "/") };
335 # It's not mountable, probably empty or some format
336 # we don't understand.
337 $r{is_mountable} = 0;
342 if ($g->is_file ("/grub/menu.lst") ||
343 $g->is_file ("/grub/grub.conf")) {
344 $r{content} = "linux-grub";
350 if ($g->is_dir ("/etc") && $g->is_dir ("/bin") &&
351 $g->is_file ("/etc/fstab")) {
352 $r{content} = "linux-root";
354 check_linux_root (\%r);
359 if ($g->is_dir ("/etc") && $g->is_dir ("/bin") &&
360 $g->is_dir ("/share") && !$g->exists ("/local") &&
361 !$g->is_file ("/etc/fstab")) {
362 $r{content} = "linux-usrlocal";
367 if ($g->is_dir ("/etc") && $g->is_dir ("/bin") &&
368 $g->is_dir ("/share") && $g->exists ("/local") &&
369 !$g->is_file ("/etc/fstab")) {
370 $r{content} = "linux-usr";
375 if ($g->is_file ("/AUTOEXEC.BAT") ||
376 $g->is_file ("/autoexec.bat") ||
377 $g->is_dir ("/Program Files") ||
378 $g->is_dir ("/WINDOWS") ||
379 $g->is_file ("/ntldr")) {
380 $r{fstype} = "ntfs"; # XXX this is a guess
381 $r{fsos} = "windows";
382 $r{content} = "windows-root";
384 check_windows_root (\%r);
399 # Look into /etc to see if we recognise the operating system.
400 if ($g->is_file ("/etc/redhat-release")) {
401 $_ = $g->cat ("/etc/redhat-release");
402 if (/Fedora release (\d+\.\d+)/) {
403 $r->{osdistro} = "fedora";
404 $r->{osversion} = "$1"
405 } elsif (/(Red Hat Enterprise Linux|CentOS|Scientific Linux).*release (\d+).*Update (\d+)/) {
406 $r->{osdistro} = "redhat";
407 $r->{osversion} = "$2.$3";
408 } elsif (/(Red Hat Enterprise Linux|CentOS|Scientific Linux).*release (\d+(?:\.(\d+))?)/) {
409 $r->{osdistro} = "redhat";
410 $r->{osversion} = "$2";
412 $r->{osdistro} = "redhat";
414 } elsif ($g->is_file ("/etc/debian_version")) {
415 $_ = $g->cat ("/etc/debian_version");
417 $r->{osdistro} = "debian";
418 $r->{osversion} = "$1";
420 $r->{osdistro} = "debian";
424 # Parse the contents of /etc/fstab. This is pretty vital so
425 # we can determine where filesystems are supposed to be mounted.
426 eval "\$_ = \$g->cat ('/etc/fstab');";
428 my @lines = split /\n/;
431 my @fields = split /[ \t]+/;
433 my $spec = $fields[0]; # first column (dev/label/uuid)
434 my $file = $fields[1]; # second column (mountpoint)
435 if ($spec =~ m{^/} ||
436 $spec =~ m{^LABEL=} ||
437 $spec =~ m{^UUID=} ||
439 push @fstab, [$spec, $file]
443 $r->{fstab} = \@fstab if @fstab;
447 sub check_windows_root
460 # Grub version, if we care.
463 #print Dumper (\%fses);
465 #----------------------------------------------------------------------
466 # Now find out how many operating systems we've got. Usually just one.
470 foreach (sort keys %fses) {
471 if ($fses{$_}->{is_root}) {
476 get_os_version (\%r);
477 assign_mount_points (\%r);
487 $r->{os} = $r->{root}->{fsos} if exists $r->{root}->{fsos};
488 $r->{distro} = $r->{root}->{osdistro} if exists $r->{root}->{osdistro};
489 $r->{version} = $r->{root}->{osversion} if exists $r->{root}->{osversion};
492 sub assign_mount_points
497 $r->{mounts} = { "/" => $r->{root_device} };
498 $r->{filesystems} = { $r->{root_device} => $r->{root} };
500 # Use /etc/fstab if we have it to mount the rest.
501 if (exists $r->{root}->{fstab}) {
502 my @fstab = @{$r->{root}->{fstab}};
504 my ($spec, $file) = @$_;
506 my ($dev, $fs) = find_filesystem ($spec);
508 $r->{mounts}->{$file} = $dev;
509 $r->{filesystems}->{$dev} = $fs;
510 if (exists $fs->{used}) {
520 # Find filesystem by device name, LABEL=.. or UUID=..
527 foreach (sort keys %fses) {
528 if (exists $fses{$_}->{label} &&
529 $fses{$_}->{label} eq $label) {
530 return ($_, $fses{$_});
533 warn "unknown filesystem label $label\n";
535 } elsif (/^UUID=(.*)/) {
537 foreach (sort keys %fses) {
538 if (exists $fses{$_}->{uuid} &&
539 $fses{$_}->{uuid} eq $uuid) {
540 return ($_, $fses{$_});
543 warn "unknown filesystem UUID $uuid\n";
546 return ($_, $fses{$_}) if exists $fses{$_};
548 if (m{^/dev/hd(.*)} && exists $fses{"/dev/sd$1"}) {
549 return ("/dev/sd$1", $fses{"/dev/sd$1"});
551 if (m{^/dev/xvd(.*)} && exists $fses{"/dev/sd$1"}) {
552 return ("/dev/sd$1", $fses{"/dev/sd$1"});
555 return () if m{/dev/cdrom};
557 warn "unknown filesystem $_\n";
562 #print Dumper(\%oses);
564 #----------------------------------------------------------------------
565 # Mount up the disks so we can check for applications
566 # and kernels. Skip this if the output is "*fish" because
567 # we don't need to know.
569 if ($output !~ /.*fish$/) {
570 # Temporary directory for use by check_for_initrd.
571 my $dir = tempdir (CLEANUP => 1);
574 foreach $root_dev (sort keys %oses) {
575 my $mounts = $oses{$root_dev}->{mounts};
576 # Have to mount / first. Luckily '/' is early in the ASCII
577 # character set, so this should be OK.
578 foreach (sort keys %$mounts) {
579 $g->mount_ro ($mounts->{$_}, $_)
580 if $_ ne "swap" && ($_ eq '/' || $g->is_dir ($_));
583 check_for_applications ($root_dev);
584 check_for_kernels ($root_dev);
585 if ($oses{$root_dev}->{os} eq "linux") {
586 check_for_modprobe_aliases ($root_dev);
587 check_for_initrd ($root_dev, $dir);
594 sub check_for_applications
597 my $root_dev = shift;
601 my $os = $oses{$root_dev}->{os};
602 if ($os eq "linux") {
603 my $distro = $oses{$root_dev}->{distro};
604 if (defined $distro && ($distro eq "redhat" || $distro eq "fedora")) {
605 my @lines = $g->command_lines
608 "--qf", "%{name} %{epoch} %{version} %{release} %{arch}\n"]);
610 if (m/^(.*) (.*) (.*) (.*) (.*)$/) {
612 $epoch = "" if $epoch eq "(none)";
624 } elsif ($os eq "windows") {
626 # I worked out a general plan for this, but haven't
627 # implemented it yet. We can iterate over /Program Files
628 # looking for *.EXE files, which we download, then use
629 # i686-pc-mingw32-windres on, to find the VERSIONINFO
630 # section, which has a lot of useful information.
633 $oses{$root_dev}->{apps} = \@apps;
636 sub check_for_kernels
639 my $root_dev = shift;
643 my $os = $oses{$root_dev}->{os};
644 if ($os eq "linux") {
645 # Installed kernels will have a corresponding /lib/modules/<version>
646 # directory, which is the easiest way to find out what kernels
647 # are installed, and what modules are available.
648 foreach ($g->ls ("/lib/modules")) {
649 if ($g->is_dir ("/lib/modules/$_")) {
651 $kernel{version} = $_;
655 foreach ($g->find ("/lib/modules/$_")) {
656 if (m,/([^/]+)\.ko$, || m,([^/]+)\.o$,) {
661 $kernel{modules} = \@modules;
663 push @kernels, \%kernel;
667 } elsif ($os eq "windows") {
671 $oses{$root_dev}->{kernels} = \@kernels;
674 # Check /etc/modprobe.conf to see if there are any specified
675 # drivers associated with network (ethX) or hard drives. Normally
676 # one might find something like:
679 # alias scsi_hostadapter xenblk
681 # XXX This doesn't look beyond /etc/modprobe.conf, eg. in /etc/modprobe.d/
683 sub check_for_modprobe_aliases
686 my $root_dev = shift;
689 eval { @lines = $g->read_lines ("/etc/modprobe.conf"); };
690 return if $@ || !@lines;
692 my %modprobe_aliases;
695 $modprobe_aliases{$1} = $2 if /^\s*alias\s+(\S+)\s+(\S+)/;
698 $oses{$root_dev}->{modprobe_aliases} = \%modprobe_aliases;
701 # Get a listing of device drivers in any initrd corresponding to a
702 # kernel. This is an indication of what can possibly be booted.
707 my $root_dev = shift;
712 foreach my $initrd ($g->ls ("/boot")) {
713 if ($initrd =~ m/^initrd-(.*)\.img$/ && $g->is_file ("/boot/$initrd")) {
716 # We have to download these to a temporary file.
717 $g->download ("/boot/$initrd", "$dir/initrd");
719 my $cmd = "zcat $dir/initrd | file -";
720 open P, "$cmd |" or die "$cmd: $!";
722 { local $/ = undef; $lines = <P>; }
724 if ($lines =~ /ext\d filesystem data/) {
725 # Before initramfs came along, these were compressed
726 # ext2 filesystems. We could run another libguestfs
727 # instance to unpack these, but punt on them for now. (XXX)
728 warn "initrd image is unsupported ext2/3/4 filesystem\n";
730 elsif ($lines =~ /cpio/) {
731 my $cmd = "zcat $dir/initrd | cpio --quiet -it";
732 open P, "$cmd |" or die "$cmd: $!";
735 if m,([^/]+)\.ko$, || m,([^/]+)\.o$,;
738 unlink "$dir/initrd";
739 $initrd_modules{$version} = \@modules;
743 warn "unrecognized initrd image: $lines\n";
748 $oses{$root_dev}->{initrd_modules} = \%initrd_modules;
751 #----------------------------------------------------------------------
754 if ($output eq "fish" || $output eq "ro-fish") {
755 my @osdevs = keys %oses;
756 # This only works if there is a single OS.
757 die "--fish output is only possible with a single OS\n" if @osdevs != 1;
759 my $root_dev = $osdevs[0];
762 if ($output eq "ro-fish") {
766 print " -a $_" foreach @images;
768 my $mounts = $oses{$root_dev}->{mounts};
769 # Have to mount / first. Luckily '/' is early in the ASCII
770 # character set, so this should be OK.
771 foreach (sort keys %$mounts) {
772 print " -m $mounts->{$_}:$_" if $_ ne "swap";
778 elsif ($output eq "perl") {
779 print Dumper(\%oses);
782 # Plain text output (the default).
783 elsif ($output eq "text") {
788 elsif ($output eq "xml") {
793 elsif ($output eq "query") {
799 output_text_os ($oses{$_}) foreach sort keys %oses;
806 print $os->{os}, " " if exists $os->{os};
807 print $os->{distro}, " " if exists $os->{distro};
808 print $os->{version}, " " if exists $os->{version};
809 print "on ", $os->{root_device}, ":\n";
811 print " Mountpoints:\n";
812 my $mounts = $os->{mounts};
813 foreach (sort keys %$mounts) {
814 printf " %-30s %s\n", $mounts->{$_}, $_
817 print " Filesystems:\n";
818 my $filesystems = $os->{filesystems};
819 foreach (sort keys %$filesystems) {
821 print " label: $filesystems->{$_}{label}\n"
822 if exists $filesystems->{$_}{label};
823 print " UUID: $filesystems->{$_}{uuid}\n"
824 if exists $filesystems->{$_}{uuid};
825 print " type: $filesystems->{$_}{fstype}\n"
826 if exists $filesystems->{$_}{fstype};
827 print " content: $filesystems->{$_}{content}\n"
828 if exists $filesystems->{$_}{content};
831 if (exists $os->{modprobe_aliases}) {
832 my %aliases = %{$os->{modprobe_aliases}};
833 my @keys = sort keys %aliases;
835 print " Modprobe aliases:\n";
837 printf " %-30s %s\n", $_, $aliases{$_}
842 if (exists $os->{initrd_modules}) {
843 my %modvers = %{$os->{initrd_modules}};
844 my @keys = sort keys %modvers;
846 print " Initrd modules:\n";
848 my @modules = @{$modvers{$_}};
850 print " $_\n" foreach @modules;
855 print " Applications:\n";
856 my @apps = @{$os->{apps}};
858 print " $_->{name} $_->{version}\n"
862 my @kernels = @{$os->{kernels}};
864 print " $_->{version}\n";
865 my @modules = @{$_->{modules}};
874 print "<operatingsystems>\n";
875 output_xml_os ($oses{$_}) foreach sort keys %oses;
876 print "</operatingsystems>\n";
883 print "<operatingsystem>\n";
885 print "<os>", $os->{os}, "</os>\n" if exists $os->{os};
886 print "<distro>", $os->{distro}, "</distro>\n" if exists $os->{distro};
887 print "<version>", $os->{version}, "</version>\n" if exists $os->{version};
888 print "<root>", $os->{root_device}, "</root>\n";
890 print "<mountpoints>\n";
891 my $mounts = $os->{mounts};
892 foreach (sort keys %$mounts) {
893 printf "<mountpoint dev='%s'>%s</mountpoint>\n",
896 print "</mountpoints>\n";
898 print "<filesystems>\n";
899 my $filesystems = $os->{filesystems};
900 foreach (sort keys %$filesystems) {
901 print "<filesystem dev='$_'>\n";
902 print "<label>$filesystems->{$_}{label}</label>\n"
903 if exists $filesystems->{$_}{label};
904 print "<uuid>$filesystems->{$_}{uuid}</uuid>\n"
905 if exists $filesystems->{$_}{uuid};
906 print "<type>$filesystems->{$_}{fstype}</type>\n"
907 if exists $filesystems->{$_}{fstype};
908 print "<content>$filesystems->{$_}{content}</content>\n"
909 if exists $filesystems->{$_}{content};
910 print "</filesystem>\n";
912 print "</filesystems>\n";
914 if (exists $os->{modprobe_aliases}) {
915 my %aliases = %{$os->{modprobe_aliases}};
916 my @keys = sort keys %aliases;
918 print "<modprobealiases>\n";
920 printf "<alias device=\"%s\">%s</alias>\n", $_, $aliases{$_}
922 print "</modprobealiases>\n";
926 if (exists $os->{initrd_modules}) {
927 my %modvers = %{$os->{initrd_modules}};
928 my @keys = sort keys %modvers;
932 my @modules = @{$modvers{$_}};
933 print "<initrd version=\"$_\">\n";
934 print "<module>$_</module>\n" foreach @modules;
937 print "</initrds>\n";
941 print "<applications>\n";
942 my @apps = @{$os->{apps}};
944 print "<application>\n";
945 print "<name>$_->{name}</name><version>$_->{version}</version>\n";
946 print "</application>\n";
948 print "</applications>\n";
951 my @kernels = @{$os->{kernels}};
954 print "<version>$_->{version}</version>\n";
956 my @modules = @{$_->{modules}};
958 print "<module>$_</module>\n";
960 print "</modules>\n";
963 print "</kernels>\n";
965 print "</operatingsystem>\n";
970 When you use C<virt-inspector --query>, the output is a series of
978 (each answer is usually C<yes> or C<no>, or the line is completely
979 missing if we could not determine the answer at all).
981 If the guest is multiboot, you can get apparently conflicting answers
982 (eg. C<windows=yes> and C<linux=yes>, or a guest which is both
983 fullvirt and has a Xen PV kernel). This is normal, and just means
984 that the guest can do both things, although it might require operator
985 intervention such as selecting a boot option when the guest is
988 This section describes the full range of answers possible.
996 output_query_windows ();
997 output_query_linux ();
998 output_query_rhel ();
999 output_query_fedora ();
1000 output_query_debian ();
1001 output_query_fullvirt ();
1002 output_query_xen_domU_kernel ();
1003 output_query_xen_pv_drivers ();
1004 output_query_virtio_drivers ();
1007 =item windows=(yes|no)
1009 Answer C<yes> if Microsoft Windows is installed in the guest.
1013 sub output_query_windows
1016 foreach my $os (keys %oses) {
1017 $windows="yes" if $oses{$os}->{os} eq "windows";
1019 print "windows=$windows\n";
1022 =item linux=(yes|no)
1024 Answer C<yes> if a Linux kernel is installed in the guest.
1028 sub output_query_linux
1031 foreach my $os (keys %oses) {
1032 $linux="yes" if $oses{$os}->{os} eq "linux";
1034 print "linux=$linux\n";
1039 Answer C<yes> if the guest contains Red Hat Enterprise Linux.
1043 sub output_query_rhel
1046 foreach my $os (keys %oses) {
1047 $rhel="yes" if $oses{$os}->{os} eq "linux" && $oses{$os}->{distro} eq "redhat";
1049 print "rhel=$rhel\n";
1052 =item fedora=(yes|no)
1054 Answer C<yes> if the guest contains the Fedora Linux distribution.
1058 sub output_query_fedora
1061 foreach my $os (keys %oses) {
1062 $fedora="yes" if $oses{$os}->{os} eq "linux" && $oses{$os}->{distro} eq "fedora";
1064 print "fedora=$fedora\n";
1067 =item debian=(yes|no)
1069 Answer C<yes> if the guest contains the Debian Linux distribution.
1073 sub output_query_debian
1076 foreach my $os (keys %oses) {
1077 $debian="yes" if $oses{$os}->{os} eq "linux" && $oses{$os}->{distro} eq "debian";
1079 print "debian=$debian\n";
1082 =item fullvirt=(yes|no)
1084 Answer C<yes> if there is at least one operating system kernel
1085 installed in the guest which runs fully virtualized. Such a guest
1086 would require a hypervisor which supports full system virtualization.
1090 sub output_query_fullvirt
1092 # The assumption is full-virt, unless all installed kernels
1093 # are identified as paravirt.
1094 # XXX Fails on Windows guests.
1095 foreach my $os (keys %oses) {
1096 foreach my $kernel (@{$oses{$os}->{kernels}}) {
1097 my $is_pv = $kernel->{version} =~ m/xen/;
1099 print "fullvirt=yes\n";
1104 print "fullvirt=no\n";
1107 =item xen_domU_kernel=(yes|no)
1109 Answer C<yes> if there is at least one Linux kernel installed in
1110 the guest which is compiled as a Xen DomU (a Xen paravirtualized
1115 sub output_query_xen_domU_kernel
1117 foreach my $os (keys %oses) {
1118 foreach my $kernel (@{$oses{$os}->{kernels}}) {
1119 my $is_xen = $kernel->{version} =~ m/xen/;
1121 print "xen_domU_kernel=yes\n";
1126 print "xen_domU_kernel=no\n";
1129 =item xen_pv_drivers=(yes|no)
1131 Answer C<yes> if the guest has Xen paravirtualized drivers installed
1132 (usually the kernel itself will be fully virtualized, but the PV
1133 drivers have been installed by the administrator for performance
1138 sub output_query_xen_pv_drivers
1140 foreach my $os (keys %oses) {
1141 foreach my $kernel (@{$oses{$os}->{kernels}}) {
1142 foreach my $module (@{$kernel->{modules}}) {
1143 if ($module =~ m/xen-/) {
1144 print "xen_pv_drivers=yes\n";
1150 print "xen_pv_drivers=no\n";
1153 =item virtio_drivers=(yes|no)
1155 Answer C<yes> if the guest has virtio paravirtualized drivers
1156 installed. Virtio drivers are commonly used to improve the
1161 sub output_query_virtio_drivers
1163 foreach my $os (keys %oses) {
1164 foreach my $kernel (@{$oses{$os}->{kernels}}) {
1165 foreach my $module (@{$kernel->{modules}}) {
1166 if ($module =~ m/virtio_/) {
1167 print "virtio_drivers=yes\n";
1173 print "virtio_drivers=no\n";
1187 Richard W.M. Jones L<http://et.redhat.com/~rjones/>
1191 Copyright (C) 2009 Red Hat Inc.
1193 This program is free software; you can redistribute it and/or modify
1194 it under the terms of the GNU General Public License as published by
1195 the Free Software Foundation; either version 2 of the License, or
1196 (at your option) any later version.
1198 This program is distributed in the hope that it will be useful,
1199 but WITHOUT ANY WARRANTY; without even the implied warranty of
1200 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1201 GNU General Public License for more details.
1203 You should have received a copy of the GNU General Public License
1204 along with this program; if not, write to the Free Software
1205 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.