virt-p2v - Man Page

 virt-p2v

 virt-p2v.iso

Virt-p2v converts a physical machine to run virtualized on KVM, managed by libvirt, OpenStack, oVirt, Red Hat Virtualisation (RHV), or one of the other targets supported by virt-v2v(1).

Normally you don’t run the virt-p2v program directly.  Instead you have to boot the physical machine using the bootable CD-ROM, ISO or PXE image.  This bootable image contains the virt-p2v binary and runs it automatically.  Booting from a CD-ROM/etc is required because the disks which are being converted must be quiescent.  It is not safe to try to convert a running physical machine where other programs may be modifying the disk content at the same time.

This manual page documents running the virt-p2v program.  To create the bootable image you should look at virt-p2v-make-disk(1) or virt-p2v-make-kickstart(1).

Virt-p2v runs on the physical machine which you want to convert.  It has to talk to another server called the "conversion server" which must have virt-v2v(1) installed on it.  It always talks to the conversion server over SSH:

 ┌──────────────┐                  ┌─────────────────┐
 │ virt-p2v     │                  │ virt-v2v        │
 │ (physical    │  ssh connection  │ (conversion     │
 │  server)   ╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍▶ server)       │
 └──────────────┘                  └─────────────────┘

The virt-v2v program on the conversion server does the actual conversion (physical to virtual, and virtual to virtual conversions are sufficiently similar that we use the same program to do both).

The SSH connection is always initiated from the physical server.  All data is transferred over the SSH connection.  In terms of firewall and network configuration, you only need to ensure that the physical server has access to a port (usually TCP port 22) on the conversion server.  Note that the physical machine may reconnect several times during the conversion process.

The reverse port forwarding feature of ssh (ie. ssh -R) is required by virt-p2v, and it will not work if this is disabled on the conversion server.  (AllowTcpForwarding must be yes in the sshd_config(5) file on the conversion server).

The scp (secure copy) feature of ssh is required by virt-p2v so it can send over small files (this is not the method by which disks are copied).

The conversion server does not need to be a physical machine.  It could be a virtual machine, as long as it has sufficient memory and disk space to do the conversion, and as long as the physical machine can connect directly to its SSH port.  (See also "Resource requirements" in virt-v2v(1)).

Because all of the data on the physical server’s hard drive(s) has to be copied over the network, the speed of conversion is largely determined by the speed of the network between the two machines.

When you start virt-p2v, you'll see a graphical configuration dialog that walks you through connection to the conversion server, asks for the password, which local hard disks you want to convert, and other things like the name of the guest to create and the number of virtual CPUs to give it.

 ┌─────────────────────────────────────────────────────────────┐
 │                           virt-p2v                          │
 │                                                             │
 │ Conversion server: [____________________________] : [22___] │
 │                                                             │
 │         User name: [root__________________________________] │
 │                                                             │
 │          Password: [______________________________________] │
 │                                                             │
 │  SSH Identity URL: [______________________________________] │
 │                                                             │

 │                                                             │
 │                    [ ] Use sudo when running virt-v2v       │
 │                                                             │

 │                                                             │
 │                     [ Test connection ]                     │
 │                                                             │
 │ [ Configure network ] [ XTerm ] [ About virt-p2v ] [ Next ] │
 │                                                             │
 └─────────────────────────────────────────────────────────────┘

 ┌─────────────────────────────────────── ─ ─ ─ ─
 │ Target properties:
 │
 │        Name: [hostname______________]
 │
 │     # vCPUs: [4_____________________]
 │
 │ Memory (MB): [16384_________________]
 │

 │
 │ Virt-v2v output options:
 │
 │          Output to (-o): [local             ▼]
 │
 │      Output conn. (-oc): [___________________]
 │
 │    Output storage (-os): [/var/tmp___________]
 │
 │     Output format (-of): [___________________]
 │
 │ Output allocation (-oa): [sparse            ▼]
 │

 ─ ─ ──────────────────────────────────────────────────┐
     Fixed hard disks                                  │
                                                       │
     Convert  Device                                   │
     [✔]      sda                                      │
              1024G HITACHI                            │
              s/n 12345                                │
     [✔]      sdb                                      │
              119G HITACHI                             │
              s/n 12346                                │
                                                       │

                                                       │
     Removable media                                   │
                                                       │
     Convert  Device                                   │
     [✔]      sr0                                      │
                                                       │

                                                       │
     Network interfaces                                │
                                                       │
     Convert  Device Connect to virtual network        │
     [✔]      em1    [default________________________] │
     [ ]      wlp3s0 [default________________________] │
                                                       │

                                                       │
     [ Back ]  [ Refresh disks ]  [ Start conversion ] │
                                                       │
 ─ ─ ──────────────────────────────────────────────────┘

 ┌────────────────────────────────────────────────────────┐
 │                      virt-p2v                          │
 │                                                        │
 │  ┌──────────────────────────────────────────────────┐  │
 │  │                                                 ▲│  │
 │  │                                                  │  │
 │  │                                                  │  │
 ∼  ∼                                                  ∼  ∼
 │  │                                                  │  │
 │  │                                                  │  │
 │  │                                                 ▼│  │
 │  └──────────────────────────────────────────────────┘  │
 │                                                        │
 │ Log files ... to /tmp/virt-p2v-xxx                     │
 │                                                        │
 │ Doing conversion ...                                   │
 │                                                        │
 │                                 [ Cancel conversion ]  │
 │                                                        │
 └────────────────────────────────────────────────────────┘

If you don’t want to configure things using the graphical UI, an alternative is to configure through the kernel command line.  This is especially convenient if you are converting a lot of physical machines which are booted using PXE.

Where exactly you set command line arguments depends on your PXE implementation, but for pxelinux you put them in the APPEND field in the pxelinux.cfg file.  For example:

 DEFAULT p2v
 TIMEOUT 20
 PROMPT 0
 LABEL p2v
   KERNEL vmlinuz0
   APPEND initrd=initrd0.img [....] p2v.server=conv.example.com p2v.password=secret p2v.o=libvirt

You have to set some or all of the following command line arguments:

p2v.remote.server=SERVER

p2v.server=SERVER

The name or IP address of the conversion server.

This is always required if you are using the kernel configuration method.  If virt-p2v does not find this on the kernel command line then it switches to the GUI (interactive) configuration method.

p2v.remote.port=PORT

p2v.port=PORT

The SSH port number on the conversion server (default: 22).

p2v.auth.username=USERNAME

p2v.username=USERNAME

The SSH username that we log in as on the conversion server (default: root).

p2v.auth.password=PASSWORD

p2v.password=PASSWORD

The SSH password that we use to log in to the conversion server.

The default is to try with no password.  If this fails then virt-p2v will ask the user to type the password (probably several times during conversion).

This setting is ignored if p2v.auth.identity.url is present.

p2v.auth.identity.url=URL

p2v.identity=URL

Provide a URL pointing to an SSH identity (private key) file.  The URL is interpreted by curl(1) so any URL that curl supports can be used here, including https:// and file://.  For more information on using SSH identities, see "SSH Identities" below.

If p2v.auth.identity.url is present, it overrides p2v.auth.password. There is no fallback.

p2v.auth.sudo

p2v.sudo

Use p2v.sudo to tell virt-p2v to use sudo(8) to gain root privileges on the conversion server after logging in as a non-root user (default: do not use sudo).

p2v.guestname=GUESTNAME

p2v.name=GUESTNAME

The name of the guest that is created.  The default is to try to derive a name from the physical machine’s hostname (if possible) else use a randomly generated name.

p2v.vcpu.phys_topo

Copy the physical machine's complete CPU topology (sockets, cores and threads) to the guest.  Disabled by default.  If disabled, the p2v.vcpu.cores setting takes effect.

p2v.vcpu.cores=N

This setting is ignored if p2v.vcpu.phys_topo is enabled.  Otherwise, it specifies the flat number of vCPU cores to give to the guest (placing all of those cores into a single socket, and exposing one thread per core).  The default value is the number of online logical processors on the physical machine.

p2v.memory=n(M|G)

The size of the guest memory.  You must specify the unit such as megabytes or gigabytes by using for example p2v.memory=1024M or p2v.memory=1G.

The default is to use the same amount of RAM as on the physical machine.

p2v.cpu.vendor=VENDOR

The vCPU vendor, eg. "Intel" or "AMD".  The default is to use the same CPU vendor as the physical machine.

p2v.cpu.model=MODEL

The vCPU model, eg. "IvyBridge".  The default is to use the same CPU model as the physical machine.

p2v.cpu.acpi

Whether to enable ACPI in the remote virtual machine.  The default is to use the same as the physical machine.

p2v.cpu.apic

Whether to enable APIC in the remote virtual machine.  The default is to use the same as the physical machine.

p2v.cpu.pae

Whether to enable PAE in the remote virtual machine.  The default is to use the same as the physical machine.

p2v.rtc.basis=(unknown|utc|localtime)

Set the basis of the Real Time Clock in the virtual machine.  The default is to try to detect this setting from the physical machine.

p2v.rtc.offset=[+|-]HOURS

The offset of the Real Time Clock from UTC.  The default is to try to detect this setting from the physical machine.

p2v.disks=sda,sdb,...

A list of physical hard disks to convert, for example:

 p2v.disks=sda,sdc

The default is to convert all local hard disks that are found.

p2v.removable=sra,srb,...

A list of removable media to convert.  The default is to create virtual removable devices for every physical removable device found. Note that the content of removable media is never copied over.

p2v.interfaces=em1,...

A list of network interfaces to convert.  The default is to create virtual network interfaces for every physical network interface found.

p2v.network_map=interface:target,...

p2v.network=interface:target,...

Controls how network interfaces are connected to virtual networks on the target hypervisor.  The default is to connect all network interfaces to the target default network.

You give a comma-separated list of interface:target pairs, plus optionally a default target.  For example:

 p2v.network=em1:ovirtmgmt

maps interface em1 to target network ovirtmgmt.

 p2v.network=em1:ovirtmgmt,em2:management,other

maps interface em1 to ovirtmgmt, and em2 to management, and any other interface that is found to other.

p2v.output.type=(libvirt|local|...)

p2v.o=(libvirt|local|...)

Set the output mode.  This is the same as the virt-v2v -o option. See "Options" in virt-v2v(1).

If not specified, the default is local, and the converted guest is written to /var/tmp.

p2v.output.allocation=(none|sparse|preallocated)

p2v.oa=(none|sparse|preallocated)

Set the output allocation mode.  This is the same as the virt-v2v -oa option.  See "Options" in virt-v2v(1).

p2v.output.connection=URI

p2v.oc=URI

Set the output connection libvirt URI.  This is the same as the virt-v2v -oc option.  See "Options" in virt-v2v(1) and http://libvirt.org/uri.html

p2v.output.format=(raw|qcow2|...)

p2v.of=(raw|qcow2|...)

Set the output format.  This is the same as the virt-v2v -of option.  See "Options" in virt-v2v(1).

p2v.output.storage=STORAGE

p2v.os=STORAGE

Set the output storage.  This is the same as the virt-v2v -os option.  See "Options" in virt-v2v(1).

If not specified, the default is /var/tmp (on the conversion server).

p2v.pre=COMMAND

p2v.pre="COMMAND ARG ..."

Select a pre-conversion command to run.  Any command or script can be specified here.  If the command contains spaces, you must quote the whole command with double quotes.  The default is not to run any command.

p2v.post=poweroff

p2v.post=reboot

p2v.post=COMMAND

p2v.post="COMMAND ARG ..."

Select a post-conversion command to run if conversion is successful. This can be any command or script.  If the command contains spaces, you must quote the whole command with double quotes.

If virt-p2v is running as root, and the command line was set from /proc/cmdline (not --cmdline), then the default is to run the poweroff(8) command.  Otherwise the default is not to run any command.

p2v.fail=COMMAND

p2v.fail="COMMAND ARG ..."

Select a post-conversion command to run if conversion fails.  Any command or script can be specified here.  If the command contains spaces, you must quote the whole command with double quotes.  The default is not to run any command.

ip=dhcp

Use DHCP for configuring the network interface (this is the default).

As a somewhat more secure alternative to password authentication, you can use an SSH identity (private key) for authentication.

First create a key pair.  It must have an empty passphrase:

 ssh-keygen -t rsa -N '' -f id_rsa

This creates a private key (id_rsa) and a public key (id_rsa.pub) pair.

The public key should be appended to the authorized_keys file on the virt-v2v conversion server (usually to /root/.ssh/authorized_keys).

For distributing the private key, there are four scenarios from least secure to most secure:

1. Not using SSH identities at all, ie. password authentication.

   Anyone who can sniff the PXE boot parameters from the network or observe the password some other way can log in to the virt-v2v conversion server.

2. SSH identity embedded in the virt-p2v ISO or disk image.  In the GUI, use:

    │          Password: [    <leave this field blank>       ] │
    │                                                          │
    │  SSH Identity URL: [file:///var/tmp/id_rsa_____________] │

   or on the kernel command line:

    p2v.identity=file:///var/tmp/id_rsa

   The SSH private key can still be sniffed from the network if using standard PXE.

3. SSH identity downloaded from a website.  In the GUI, use:

    │          Password: [    <leave this field blank>       ] │
    │                                                          │
    │  SSH Identity URL: [https://internal.example.com/id_rsa] │

   or on the kernel command line:

    p2v.identity=https://internal.example.com/id_rsa

   Anyone could still download the private key and use it to log in to the virt-v2v conversion server, but you could provide some extra security by configuring the web server to only allow connections from P2V machines.

   Note that ssh-keygen(1) creates the id_rsa (private key) file with mode 0600.  If you simply copy the file to a webserver, the webserver will not serve it.  It will reply with "403 Forbidden" errors.  You will need to change the mode of the file to make it publicly readable, for example by using:

    chmod 0644 id_rsa

4. SSH identity embedded in the virt-p2v ISO or disk image (like 2.), and use of secure PXE, PXE over separate physical network, or sneakernet to distribute virt-p2v to the physical machine.

Both virt-p2v-make-disk(1) and virt-p2v-make-kickstart(1) have the same option --inject-ssh-identity for injecting the private key into the virt-p2v disk image / ISO.  See also the following manual sections:

"ADDING AN SSH IDENTITY" in virt-p2v-make-disk(1)

"ADDING AN SSH IDENTITY" in virt-p2v-make-kickstart(1)

In case the disk that contains the operating system, or other disks that you want to convert, are LUNs of remote iSCSI targets, follow the steps below so that virt-p2v can learn about said disks.  Note that this procedure depends on the use of the GUI.

The guide below is roughly based on the RHEL9 product documentation.

1. Open a shell in an XTerm window, using the XTerm button of the "SSH Configuration Dialog".

   (Note that the XTerm window(s) persist while you advance to further dialogs in virt-p2v, therefore it's unnecessary to jump back and forth between virt-p2v dialogs just for entering additional shell commands in the XTerm window(s).)

2. Using vi or another text editor, set the iSCSI initiator name in /etc/iscsi/initiatorname.iscsi, for example:

    InitiatorName=iqn.1994-05.com.redhat:846e82c634

   If the file does not exist, create it.  (Remember that this file is part of the virt-p2v Live environment, therefore saving it does not modify any hard disks.)

3. Configure any further iSCSI initiator details completely that are required by the iSCSI target that you intend to log in to; that is, before you issue the first iscsiadm command below.  This includes the CHAP user name and password if the target authenticates the initiator with CHAP, and the reverse direction CHAP user name and password too, if you want to ascertain the identity of the target on the initiator as well (this is called "mutual authentication").

   Completing the configuration at this stage is important because the first iscsiadm command will start up the iscsid service, and configuration changes with that service already running will not (or may not) take effect until/unless you restart the service using systemctl.

4. Discover the iSCSI targets offered by the desired host:

    iscsiadm -m discovery -t st -p IP_ADDRESS

   The command should respond with a two-column list of targets.  The symbolic target names are in the right hand side column, for example:

        10.64.24.179:3260,1 iqn.2006-04.example:444

5. Picking an appropriate target from the right hand side column of the previous step's output, log in to the target:

    iscsiadm -m node -T TARGET -l

   This command will inform you whether the login attempt was successful.

6. In case the login succeeds, a scan for LUNs on the iSCSI target will commence at once.  There are two pitfalls here.  One, dependent on network characteristics, the scan may take several (tens of) seconds. Two, even if the login succeeds, ACLs on the target may silently prevent the initiator from seeing particular LUNs -- meaning that no new /dev/sdX nodes will appear.  This is why it is important to get the initiator name (and, potentially, CHAP authentication) correct at the very beginning of this procedure.

   Verify the results of the target scan with the dmesg command, and/or with

    ls -l /dev/disk/by-path/ip-*-iscsi-*-lun-*

   If these symlinks exist, containing the IP_ADDRESS from step 4 and the TARGET name from step 5 in their filenames, then the target scan has successfully found the corresponding LUNs.

7. Once the remote LUNs have been successfully enumerated, click the Refresh disks button in the "Disk and Network Configuration Dialog".

--help

Display help.

--cmdline=CMDLINE

This is used for debugging. Instead of parsing the kernel command line from /proc/cmdline, parse the string parameter CMDLINE.

--colors

--colours

Use ANSI colour sequences to colourize messages.  This is the default when the output is a tty.  If the output of the program is redirected to a file, ANSI colour sequences are disabled unless you use this option.

--iso

This flag is passed to virt-p2v when it is launched inside the virt-p2v ISO environment, ie. when it is running on a real physical machine (and thus not when testing).  It enables various dangerous features such as the Shutdown popup button.

--test-disk=/PATH/TO/DISK.IMG

For testing or debugging purposes, replace /dev/sda with a local file.  You must use an absolute path.  Note that the Refresh disks button will be disabled in the "Disk and Network Configuration Dialog" of the GUI.

-v

--verbose

In libguestfs ≥ 1.33.41, debugging is always enabled on the conversion server, and this option does nothing.

-V

--version

Display version number and exit.

Note this section is not normative.  We may change how virt-p2v works at any time in the future.

As described above, virt-p2v runs on a physical machine, interrogates the user or the kernel command line for configuration, and then establishes one or more ssh connections to the virt-v2v conversion server.  The ssh connections are interactive shell sessions to the remote host, but the commands sent are generated entirely by virt-p2v itself, not by the user.  For data transfer, virt-p2v will use the reverse port forward feature of ssh (ie. ssh -R).

It will first make one or more test connections, which are used to query the remote version of virt-v2v and its features.  The test connections are closed before conversion begins.

 ┌──────────────┐                      ┌─────────────────┐
 │ virt-p2v     │                      │ virt-v2v        │
 │ (physical    │  control connection  │ (conversion     │
 │  server)   ╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍▶ server)       │
 └──────────────┘                      └─────────────────┘

Once virt-p2v is ready to start conversion, it will open a single ssh control connection.  It first sends a mkdir command to create a temporary directory on the conversion server.  The directory name is randomly chosen and is displayed in the GUI.  It has the form:

 /tmp/virt-p2v-YYYYMMDD-XXXXXXXX

where YYYYMMDD is the current date, and the ‘X’s are random characters.

Into this directory are written various files which include:

dmesg

lscpu

lspci

lsscsi

lsusb

(before conversion)

The output of the corresponding commands (ie dmesg(1), lscpu(1) etc) on the physical machine.

The dmesg output is useful for detecting problems such as missing device drivers or firmware on the virt-p2v ISO.  The others are useful for debugging novel hardware configurations.

environment

(before conversion)

The content of the environment where virt-v2v(1) will run.

name

(before conversion)

The name (usually the hostname) of the physical machine.

physical.xml

(before conversion)

Libvirt XML describing the physical machine.  It is used to pass data about the physical source host to virt-v2v(1) via the -i libvirtxml option.

Note this is not "real" libvirt XML (and must never be loaded into libvirt, which would reject it anyhow).  Also it is not the same as the libvirt XML which virt-v2v generates in certain output modes.

p2v-version

v2v-version

(before conversion)

The versions of virt-p2v and virt-v2v respectively.

status

(after conversion)

The final status of the conversion.  0 if the conversion was successful.  Non-zero if the conversion failed.

time

(before conversion)

The start date/time of conversion.

virt-v2v-conversion-log.txt

(during/after conversion)

The conversion log.  This is just the output of the virt-v2v command on the conversion server.  If conversion fails, you should examine this log file, and you may be asked to supply the complete, unedited log file in any bug reports or support tickets.

virt-v2v-wrapper.sh

(before conversion)

This is the wrapper script which is used when running virt-v2v.  For interest only, do not attempt to run this script yourself.

Before conversion actually begins, virt-p2v then makes one or more further ssh connections to the server for data transfer.

The transfer protocol used currently is NBD (Network Block Device), which is proxied over ssh.  The NBD server is nbdkit(1), with nbdkit-file-plugin(1) and socket activation.

There is one ssh connection per physical hard disk on the source machine (the common case — a single hard disk — is shown below):

 ┌──────────────┐                      ┌─────────────────┐
 │ virt-p2v     │                      │ virt-v2v        │
 │ (physical    │  control connection  │ (conversion     │
 │  server)   ╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍▶ server)       │
 │              │                      │                 │
 │              │  data connection     │                 │
 │            ╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍▶               │
 │ nbdkit  ← ─┘ │                      │└─ ← NBD         │
 │ /dev/sda     │                      │     requests    │
 ∼              ∼                      ∼                 ∼
 └──────────────┘                      └─────────────────┘

Although the ssh data connection is originated from the physical server and terminates on the conversion server, in fact NBD requests flow in the opposite direction.  This is because the reverse port forward feature of ssh (ssh -R) is used to open a port on the loopback interface of the conversion server which is proxied back by ssh to nbdkit running on the physical machine.  The effect is that virt-v2v via libguestfs can open nbd connections which directly read the hard disk(s) of the physical server.

Two layers of protection are used to ensure that there are no writes to the hard disks: Firstly, the nbdkit -r (readonly) option is used.  Secondly libguestfs creates an overlay on top of the NBD connection which stores writes in a temporary file on the conversion file.

The long virt-v2v -i libvirtxml physical.xml ... command is wrapped inside a wrapper script and uploaded to the conversion server. The final step is to run this wrapper script, in turn running the virt-v2v command.  The virt-v2v command references the physical.xml file (see above), which in turn references the NBD listening port(s) of the data connection(s).

Output from the virt-v2v command (messages, debugging etc) is saved in the log file on the conversion server.  Only informational messages are sent back over the control connection to be displayed in the graphical UI.

virt-p2v-make-disk(1), virt-p2v-make-kickstart(1), virt-p2v-make-kiwi(1), virt-v2v(1), nbdkit(1), nbdkit-file-plugin(1), ssh(1), sshd(8), sshd_config(5), http://libguestfs.org/.

Matthew Booth

John Eckersberg

Richard W.M. Jones http://people.redhat.com/~rjones/

Mike Latimer

Pino Toscano

Tingting Zheng

Copyright (C) 2009-2019 Red Hat Inc.

This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.

To get a list of bugs against libguestfs (which include virt-p2v), use this link: https://bugzilla.redhat.com/buglist.cgi?component=libguestfs&product=Virtualization+Tools

To report a new bug against libguestfs, use this link: https://bugzilla.redhat.com/enter_bug.cgi?component=libguestfs&product=Virtualization+Tools

When reporting a bug, please supply:

• The version of virt-p2v.
• Where you got virt-p2v (eg. which Linux distro, compiled from source, etc)
• Describe the bug accurately and give a way to reproduce it.

guestfish(1), guestfs(3), guestfs-release-notes-1.28(1), guestfs-release-notes-1.30(1), virt-p2v-make-disk(1), virt-p2v-make-kickstart(1), virt-p2v-make-kiwi(1), virt-v2v(1), virt-v2v-hacking(1), virt-v2v-in-place(1), virt-v2v-inspector(1), virt-v2v-support(1).