1
0
mirror of https://github.com/GNS3/gns3-server synced 2024-12-11 09:38:08 +00:00
gns3-server/gns3server/compute/qemu/qemu_vm.py

2541 lines
93 KiB
Python
Raw Normal View History

2015-02-19 10:33:25 +00:00
#
# Copyright (C) 2014 GNS3 Technologies 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 3 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 <http://www.gnu.org/licenses/>.
"""
2015-04-08 17:17:34 +00:00
QEMU VM management (creates command line, processes, files etc.) in
order to run a QEMU VM.
2015-02-19 10:33:25 +00:00
"""
import sys
import os
import re
import math
2015-02-19 10:33:25 +00:00
import shutil
2020-04-15 18:50:59 +00:00
import struct
import asyncio
import socket
2015-06-03 04:33:38 +00:00
import gns3server
import subprocess
import time
import json
2022-01-19 11:58:36 +00:00
import shlex
2015-02-19 10:33:25 +00:00
2022-01-19 11:58:36 +00:00
from gns3server.utils import parse_version
from gns3server.utils.asyncio import subprocess_check_output, cancellable_wait_run_in_executor
2015-02-19 10:33:25 +00:00
from .qemu_error import QemuError
from .utils.qcow2 import Qcow2, Qcow2Error
from .utils.ziputils import pack_zip, unpack_zip
2015-02-19 10:33:25 +00:00
from ..adapters.ethernet_adapter import EthernetAdapter
from ..error import NodeError, ImageMissingError
from ..nios.nio_udp import NIOUDP
from ..nios.nio_tap import NIOTAP
from ..base_node import BaseNode
from ...utils.asyncio import monitor_process
from ...utils.images import md5sum
from ...utils import macaddress_to_int, int_to_macaddress
from ...utils.hostname import is_rfc1123_hostname_valid
from gns3server.schemas.compute.qemu_nodes import Qemu, QemuPlatform
2015-02-19 10:33:25 +00:00
import logging
2021-04-13 09:16:50 +00:00
2015-02-19 10:33:25 +00:00
log = logging.getLogger(__name__)
class QemuVM(BaseNode):
2021-04-13 09:16:50 +00:00
module_name = "qemu"
2015-02-19 10:33:25 +00:00
"""
QEMU VM implementation.
2015-04-08 17:17:34 +00:00
:param name: Qemu VM name
:param node_id: Node identifier
2015-02-19 10:33:25 +00:00
:param project: Project instance
2015-04-08 17:17:34 +00:00
:param manager: Manager instance
2015-02-19 10:33:25 +00:00
:param console: TCP console port
2018-03-24 11:11:21 +00:00
:param console_type: Console type
2015-02-19 10:33:25 +00:00
:param qemu_path: path to the QEMU binary
:param platform: Platform to emulate
2015-02-19 10:33:25 +00:00
"""
2021-04-13 09:16:50 +00:00
def __init__(
self,
name,
node_id,
project,
manager,
linked_clone=True,
qemu_path=None,
console=None,
console_type="telnet",
aux=None,
aux_type="none",
platform=None,
):
if not is_rfc1123_hostname_valid(name):
raise QemuError(f"'{name}' is an invalid name to create a Qemu node")
2021-04-13 09:16:50 +00:00
super().__init__(
name,
node_id,
project,
manager,
console=console,
console_type=console_type,
linked_clone=linked_clone,
aux=aux,
aux_type=aux_type,
wrap_console=True,
wrap_aux=True,
)
self._host = manager.config.settings.Server.host
self._monitor_host = manager.config.settings.Qemu.monitor_host
2015-02-19 10:33:25 +00:00
self._process = None
self._cpulimit_process = None
self._monitor = None
2015-02-19 10:33:25 +00:00
self._stdout_file = ""
self._qemu_img_stdout_file = ""
self._execute_lock = asyncio.Lock()
self._local_udp_tunnels = {}
self._guest_cid = None
self._command_line_changed = False
2015-02-19 10:33:25 +00:00
2015-04-08 17:17:34 +00:00
# QEMU VM settings
if qemu_path:
try:
self.qemu_path = qemu_path
except QemuError:
2016-05-18 09:23:45 +00:00
# If the binary is not found for topologies 1.4 and later
# search via the platform otherwise use the binary name
if platform:
self.platform = platform
else:
self.qemu_path = os.path.basename(qemu_path)
else:
self.platform = platform
2015-02-19 10:33:25 +00:00
self._hda_disk_image = ""
self._hdb_disk_image = ""
self._hdc_disk_image = ""
self._hdd_disk_image = ""
self._hda_disk_interface = "none"
self._hdb_disk_interface = "none"
self._hdc_disk_interface = "none"
self._hdd_disk_interface = "none"
self._cdrom_image = ""
self._bios_image = ""
self._boot_priority = "c"
self._mac_address = ""
2015-02-19 10:33:25 +00:00
self._options = ""
self._ram = 256
2015-08-05 23:17:55 +00:00
self._cpus = 1
self._maxcpus = 1
2015-02-19 10:33:25 +00:00
self._ethernet_adapters = []
self._adapter_type = "e1000"
self._initrd = ""
self._kernel_image = ""
self._kernel_command_line = ""
self._replicate_network_connection_state = True
self._create_config_disk = False
self._on_close = "power_off"
2015-02-19 10:33:25 +00:00
self._cpu_throttling = 0 # means no CPU throttling
self._process_priority = "low"
self.mac_address = "" # this will generate a MAC address
2015-02-19 10:33:25 +00:00
self.adapters = 1 # creates 1 adapter by default
# config disk
self.config_disk_name = self.manager.config_disk
self.config_disk_image = ""
2020-08-13 07:40:31 +00:00
if self.config_disk_name:
if not shutil.which("mcopy"):
log.warning("Config disk: 'mtools' are not installed.")
self.config_disk_name = ""
2020-08-13 07:40:31 +00:00
else:
try:
self.config_disk_image = self.manager.get_abs_image_path(self.config_disk_name)
except (NodeError, ImageMissingError):
2021-04-13 09:07:58 +00:00
log.warning(f"Config disk: image '{self.config_disk_name}' missing")
2020-08-13 07:40:31 +00:00
self.config_disk_name = ""
2021-04-13 09:07:58 +00:00
log.info(f'QEMU VM "{self._name}" [{self._id}] has been created')
2015-02-19 10:33:25 +00:00
@BaseNode.name.setter
def name(self, new_name):
"""
Sets the name of this Qemu VM.
:param new_name: name
"""
if not is_rfc1123_hostname_valid(new_name):
raise QemuError(f"'{new_name}' is an invalid name to rename Qemu node '{self._name}'")
super(QemuVM, QemuVM).name.__set__(self, new_name)
@property
def guest_cid(self):
"""
Returns the CID (console ID) which is an unique identifier between 3 and 65535
:returns: integer between 3 and 65535
"""
return self._guest_cid
@guest_cid.setter
def guest_cid(self, guest_cid):
"""
Set the CID (console ID) which is an unique identifier between 3 and 65535
:returns: integer between 3 and 65535
"""
self._guest_cid = guest_cid
2015-02-19 10:33:25 +00:00
@property
def monitor(self):
"""
Returns the TCP monitor port.
:returns: monitor port (integer)
"""
return self._monitor
@property
def qemu_path(self):
"""
Returns the QEMU binary path for this QEMU VM.
:returns: QEMU path
"""
return self._qemu_path
@qemu_path.setter
def qemu_path(self, qemu_path):
"""
Sets the QEMU binary path this QEMU VM.
:param qemu_path: QEMU path
"""
if qemu_path and os.pathsep not in qemu_path:
new_qemu_path = shutil.which(qemu_path, path=os.pathsep.join(self._manager.paths_list()))
if new_qemu_path is None:
2021-04-13 09:07:58 +00:00
raise QemuError(f"QEMU binary path {qemu_path} is not found in the path")
qemu_path = new_qemu_path
self._check_qemu_path(qemu_path)
self._qemu_path = qemu_path
self._platform = os.path.basename(qemu_path)
if self._platform == "qemu-kvm":
self._platform = "x86_64"
else:
qemu_bin = os.path.basename(qemu_path)
2021-04-13 09:16:50 +00:00
qemu_bin = re.sub(r"(w)?\.(exe|EXE)$", "", qemu_bin)
# Old version of GNS3 provide a binary named qemu.exe
if qemu_bin == "qemu":
self._platform = "i386"
else:
2021-04-13 09:16:50 +00:00
self._platform = re.sub(r"^qemu-system-(.*)$", r"\1", qemu_bin, re.IGNORECASE)
2020-10-31 05:32:21 +00:00
try:
QemuPlatform(self._platform.split(".")[0])
except ValueError:
2021-04-13 09:07:58 +00:00
raise QemuError(f"Platform {self._platform} is unknown")
2021-04-13 09:16:50 +00:00
log.info(
'QEMU VM "{name}" [{id}] has set the QEMU path to {qemu_path}'.format(
name=self._name, id=self._id, qemu_path=qemu_path
)
)
def _check_qemu_path(self, qemu_path):
2018-03-15 07:17:39 +00:00
if qemu_path is None:
raise QemuError("QEMU binary path is not set")
if not os.path.exists(qemu_path):
2021-04-13 09:07:58 +00:00
raise QemuError(f"QEMU binary '{qemu_path}' is not accessible")
if not os.access(qemu_path, os.X_OK):
2021-04-13 09:07:58 +00:00
raise QemuError(f"QEMU binary '{qemu_path}' is not executable")
@property
def platform(self):
"""
Return the current platform
"""
return self._platform
@platform.setter
def platform(self, platform):
2018-03-15 07:17:39 +00:00
self._platform = platform
2022-01-19 11:58:36 +00:00
self.qemu_path = f"qemu-system-{platform}"
2015-02-19 10:33:25 +00:00
def _disk_setter(self, variable, value):
"""
Use by disk image setter for checking and apply modifications
:param variable: Variable name in the class
:param value: New disk value
"""
2018-03-15 07:17:39 +00:00
value = self.manager.get_abs_image_path(value, self.working_dir)
if not self.linked_clone:
for node in self.manager.nodes:
if node != self and getattr(node, variable) == value:
2021-04-13 09:16:50 +00:00
raise QemuError(
f"Sorry a node without the linked base setting enabled can only be used once on your server. {value} is already used by {node.name} in project {node.project.name}"
2021-04-13 09:16:50 +00:00
)
setattr(self, "_" + variable, value)
2021-04-13 09:16:50 +00:00
log.info(
'QEMU VM "{name}" [{id}] has set the QEMU {variable} path to {disk_image}'.format(
name=self._name, variable=variable, id=self._id, disk_image=value
)
)
2015-02-19 10:33:25 +00:00
@property
def hda_disk_image(self):
"""
Returns the hda disk image path for this QEMU VM.
:returns: QEMU hda disk image path
"""
return self._hda_disk_image
@hda_disk_image.setter
def hda_disk_image(self, hda_disk_image):
"""
Sets the hda disk image for this QEMU VM.
:param hda_disk_image: QEMU hda disk image path
"""
2018-03-15 07:17:39 +00:00
self._disk_setter("hda_disk_image", hda_disk_image)
2015-02-19 10:33:25 +00:00
@property
def hdb_disk_image(self):
"""
Returns the hdb disk image path for this QEMU VM.
:returns: QEMU hdb disk image path
"""
return self._hdb_disk_image
@hdb_disk_image.setter
def hdb_disk_image(self, hdb_disk_image):
"""
Sets the hdb disk image for this QEMU VM.
:param hdb_disk_image: QEMU hdb disk image path
"""
self._disk_setter("hdb_disk_image", hdb_disk_image)
2015-02-19 10:33:25 +00:00
@property
def hdc_disk_image(self):
"""
Returns the hdc disk image path for this QEMU VM.
:returns: QEMU hdc disk image path
"""
return self._hdc_disk_image
@hdc_disk_image.setter
def hdc_disk_image(self, hdc_disk_image):
"""
Sets the hdc disk image for this QEMU VM.
:param hdc_disk_image: QEMU hdc disk image path
"""
self._disk_setter("hdc_disk_image", hdc_disk_image)
@property
def hdd_disk_image(self):
"""
Returns the hdd disk image path for this QEMU VM.
:returns: QEMU hdd disk image path
"""
return self._hdd_disk_image
@hdd_disk_image.setter
def hdd_disk_image(self, hdd_disk_image):
"""
Sets the hdd disk image for this QEMU VM.
:param hdd_disk_image: QEMU hdd disk image path
"""
self._disk_setter("hdd_disk_image", hdd_disk_image)
@property
def hda_disk_interface(self):
"""
Returns the hda disk interface this QEMU VM.
:returns: QEMU hda disk interface
"""
return self._hda_disk_interface
@hda_disk_interface.setter
def hda_disk_interface(self, hda_disk_interface):
"""
Sets the hda disk interface for this QEMU VM.
:param hda_disk_interface: QEMU hda disk interface
"""
self._hda_disk_interface = hda_disk_interface
2021-04-13 09:16:50 +00:00
log.info(
'QEMU VM "{name}" [{id}] has set the QEMU hda disk interface to {interface}'.format(
name=self._name, id=self._id, interface=self._hda_disk_interface
)
)
@property
def hdb_disk_interface(self):
"""
Returns the hdb disk interface this QEMU VM.
:returns: QEMU hdb disk interface
"""
return self._hdb_disk_interface
@hdb_disk_interface.setter
def hdb_disk_interface(self, hdb_disk_interface):
"""
Sets the hda disk interface for this QEMU VM.
:param hdb_disk_interface: QEMU hdb disk interface
"""
self._hdb_disk_interface = hdb_disk_interface
2021-04-13 09:16:50 +00:00
log.info(
'QEMU VM "{name}" [{id}] has set the QEMU hdb disk interface to {interface}'.format(
name=self._name, id=self._id, interface=self._hdb_disk_interface
)
)
@property
def hdc_disk_interface(self):
"""
Returns the hdc disk interface this QEMU VM.
:returns: QEMU hdc disk interface
"""
return self._hdc_disk_interface
@hdc_disk_interface.setter
def hdc_disk_interface(self, hdc_disk_interface):
"""
Sets the hdc disk interface for this QEMU VM.
:param hdc_disk_interface: QEMU hdc disk interface
"""
self._hdc_disk_interface = hdc_disk_interface
2021-04-13 09:16:50 +00:00
log.info(
'QEMU VM "{name}" [{id}] has set the QEMU hdc disk interface to {interface}'.format(
name=self._name, id=self._id, interface=self._hdc_disk_interface
)
)
@property
def hdd_disk_interface(self):
"""
Returns the hda disk interface this QEMU VM.
:returns: QEMU hda disk interface
"""
return self._hdd_disk_interface
@hdd_disk_interface.setter
def hdd_disk_interface(self, hdd_disk_interface):
"""
Sets the hdd disk interface for this QEMU VM.
:param hdd_disk_interface: QEMU hdd disk interface
"""
self._hdd_disk_interface = hdd_disk_interface
2021-04-13 09:16:50 +00:00
log.info(
'QEMU VM "{name}" [{id}] has set the QEMU hdd disk interface to {interface}'.format(
name=self._name, id=self._id, interface=self._hdd_disk_interface
)
)
@property
def cdrom_image(self):
"""
Returns the cdrom image path for this QEMU VM.
:returns: QEMU cdrom image path
"""
return self._cdrom_image
@cdrom_image.setter
def cdrom_image(self, cdrom_image):
"""
Sets the cdrom image for this QEMU VM.
:param cdrom_image: QEMU cdrom image path
"""
if cdrom_image:
self._cdrom_image = self.manager.get_abs_image_path(cdrom_image, self.working_dir)
2021-04-13 09:16:50 +00:00
log.info(
'QEMU VM "{name}" [{id}] has set the QEMU cdrom image path to {cdrom_image}'.format(
name=self._name, id=self._id, cdrom_image=self._cdrom_image
)
)
else:
self._cdrom_image = ""
async def update_property(self, name, value):
"""
Update Qemu VM properties.
"""
setattr(self, name, value)
if name == "cdrom_image":
# let the guest know about the new cdrom image
await self._update_cdrom_image()
self._command_line_changed = True
async def _update_cdrom_image(self):
"""
Update the cdrom image path for the Qemu guest OS
"""
if self.is_running():
if self._cdrom_image:
self._cdrom_option() # this will check the cdrom image is accessible
await self._control_vm("eject -f ide1-cd0")
2021-04-13 09:07:58 +00:00
await self._control_vm(f"change ide1-cd0 {self._cdrom_image}")
2021-04-13 09:16:50 +00:00
log.info(
'QEMU VM "{name}" [{id}] has changed the cdrom image path to {cdrom_image}'.format(
name=self._name, id=self._id, cdrom_image=self._cdrom_image
)
)
else:
await self._control_vm("eject -f ide1-cd0")
2021-04-13 09:07:58 +00:00
log.info(f'QEMU VM "{self._name}" [{self._id}] has ejected the cdrom image')
@property
def bios_image(self):
"""
Returns the bios image path for this QEMU VM.
:returns: QEMU bios image path
"""
return self._bios_image
@bios_image.setter
def bios_image(self, bios_image):
"""
Sets the bios image for this QEMU VM.
:param bios_image: QEMU bios image path
"""
self._bios_image = self.manager.get_abs_image_path(bios_image, self.working_dir)
2021-04-13 09:16:50 +00:00
log.info(
'QEMU VM "{name}" [{id}] has set the QEMU bios image path to {bios_image}'.format(
name=self._name, id=self._id, bios_image=self._bios_image
)
)
@property
def boot_priority(self):
"""
Returns the boot priority for this QEMU VM.
:returns: QEMU boot priority
"""
return self._boot_priority
@boot_priority.setter
def boot_priority(self, boot_priority):
"""
Sets the boot priority for this QEMU VM.
:param boot_priority: QEMU boot priority
"""
self._boot_priority = boot_priority
2021-04-13 09:16:50 +00:00
log.info(
'QEMU VM "{name}" [{id}] has set the boot priority to {boot_priority}'.format(
name=self._name, id=self._id, boot_priority=self._boot_priority
)
)
@property
def ethernet_adapters(self):
"""
Return the list of ethernet adapters of the node
"""
return self._ethernet_adapters
2015-02-19 10:33:25 +00:00
@property
def adapters(self):
"""
2015-04-08 17:17:34 +00:00
Returns the number of Ethernet adapters for this QEMU VM.
2015-02-19 10:33:25 +00:00
:returns: number of adapters
"""
return len(self._ethernet_adapters)
@adapters.setter
def adapters(self, adapters):
"""
2015-04-08 17:17:34 +00:00
Sets the number of Ethernet adapters for this QEMU VM.
2015-02-19 10:33:25 +00:00
:param adapters: number of adapters
"""
self._ethernet_adapters.clear()
2015-04-08 17:17:34 +00:00
for adapter_number in range(0, adapters):
2015-02-19 10:33:25 +00:00
self._ethernet_adapters.append(EthernetAdapter())
2021-04-13 09:16:50 +00:00
log.info(
'QEMU VM "{name}" [{id}]: number of Ethernet adapters changed to {adapters}'.format(
name=self._name, id=self._id, adapters=adapters
)
)
2015-02-19 10:33:25 +00:00
@property
def adapter_type(self):
"""
2015-04-08 17:17:34 +00:00
Returns the adapter type for this QEMU VM.
2015-02-19 10:33:25 +00:00
:returns: adapter type (string)
"""
return self._adapter_type
@adapter_type.setter
def adapter_type(self, adapter_type):
"""
2015-04-08 17:17:34 +00:00
Sets the adapter type for this QEMU VM.
2015-02-19 10:33:25 +00:00
:param adapter_type: adapter type (string)
"""
self._adapter_type = adapter_type
2021-04-13 09:16:50 +00:00
log.info(
'QEMU VM "{name}" [{id}]: adapter type changed to {adapter_type}'.format(
name=self._name, id=self._id, adapter_type=adapter_type
)
)
2015-02-19 10:33:25 +00:00
@property
def mac_address(self):
"""
Returns the MAC address for this QEMU VM.
:returns: adapter type (string)
"""
return self._mac_address
@mac_address.setter
def mac_address(self, mac_address):
"""
Sets the MAC address for this QEMU VM.
:param mac_address: MAC address
"""
if not mac_address:
# use the node UUID to generate a random MAC address
self._mac_address = f"0c:{self.id[2:4]}:{self.id[4:6]}:{self.id[6:8]}:00:00"
else:
self._mac_address = mac_address
2021-04-13 09:16:50 +00:00
log.info(
'QEMU VM "{name}" [{id}]: MAC address changed to {mac_addr}'.format(
name=self._name, id=self._id, mac_addr=self._mac_address
)
)
@property
def replicate_network_connection_state(self):
"""
Returns whether the network connection state for links is replicated in QEMU.
:returns: boolean
"""
return self._replicate_network_connection_state
@replicate_network_connection_state.setter
def replicate_network_connection_state(self, replicate_network_connection_state):
"""
Sets whether the network connection state for links is replicated in QEMU
:param replicate_network_connection_state: boolean
"""
if replicate_network_connection_state:
2021-04-13 09:07:58 +00:00
log.info(f'QEMU VM "{self._name}" [{self._id}] has enabled network connection state replication')
else:
2021-04-13 09:07:58 +00:00
log.info(f'QEMU VM "{self._name}" [{self._id}] has disabled network connection state replication')
self._replicate_network_connection_state = replicate_network_connection_state
@property
def create_config_disk(self):
"""
Returns whether a config disk is automatically created on HDD disk interface (secondary slave)
:returns: boolean
"""
return self._create_config_disk
@create_config_disk.setter
def create_config_disk(self, create_config_disk):
"""
Sets whether a config disk is automatically created on HDD disk interface (secondary slave)
:param replicate_network_connection_state: boolean
"""
if create_config_disk:
2021-04-13 09:07:58 +00:00
log.info(f'QEMU VM "{self._name}" [{self._id}] has enabled the config disk creation feature')
else:
2021-04-13 09:07:58 +00:00
log.info(f'QEMU VM "{self._name}" [{self._id}] has disabled the config disk creation feature')
self._create_config_disk = create_config_disk
2015-06-03 04:33:38 +00:00
@property
def on_close(self):
2015-06-03 04:33:38 +00:00
"""
Returns the action to execute when the VM is stopped/closed
2015-06-03 04:33:38 +00:00
:returns: string
"""
return self._on_close
@on_close.setter
def on_close(self, on_close):
"""
Sets the action to execute when the VM is stopped/closed
:param on_close: string
"""
2021-04-13 09:07:58 +00:00
log.info(f'QEMU VM "{self._name}" [{self._id}] set the close action to "{on_close}"')
self._on_close = on_close
2015-02-19 10:33:25 +00:00
@property
def cpu_throttling(self):
"""
Returns the percentage of CPU allowed.
:returns: integer
"""
return self._cpu_throttling
@cpu_throttling.setter
def cpu_throttling(self, cpu_throttling):
"""
Sets the percentage of CPU allowed.
:param cpu_throttling: integer
"""
2021-04-13 09:16:50 +00:00
log.info(
'QEMU VM "{name}" [{id}] has set the percentage of CPU allowed to {cpu}'.format(
name=self._name, id=self._id, cpu=cpu_throttling
)
)
2015-02-19 10:33:25 +00:00
self._cpu_throttling = cpu_throttling
self._stop_cpulimit()
if cpu_throttling:
self._set_cpu_throttling()
@property
def process_priority(self):
"""
Returns the process priority.
:returns: string
"""
return self._process_priority
@process_priority.setter
def process_priority(self, process_priority):
"""
Sets the process priority.
:param process_priority: string
"""
2021-04-13 09:16:50 +00:00
log.info(
'QEMU VM "{name}" [{id}] has set the process priority to {priority}'.format(
name=self._name, id=self._id, priority=process_priority
)
)
2015-02-19 10:33:25 +00:00
self._process_priority = process_priority
@property
def ram(self):
"""
Returns the RAM amount for this QEMU VM.
:returns: RAM amount in MB
"""
return self._ram
@ram.setter
def ram(self, ram):
"""
Sets the amount of RAM for this QEMU VM.
:param ram: RAM amount in MB
"""
2021-04-13 09:07:58 +00:00
log.info(f'QEMU VM "{self._name}" [{self._id}] has set the RAM to {ram}')
2015-02-19 10:33:25 +00:00
self._ram = ram
2015-08-05 23:17:55 +00:00
@property
def cpus(self):
"""
Returns the number of vCPUs this QEMU VM.
:returns: number of vCPUs.
"""
return self._cpus
@cpus.setter
def cpus(self, cpus):
"""
Sets the number of vCPUs this QEMU VM.
:param cpus: number of vCPUs.
"""
2021-04-13 09:07:58 +00:00
log.info(f'QEMU VM "{self._name}" [{self._id}] has set the number of vCPUs to {cpus}')
2015-08-05 23:17:55 +00:00
self._cpus = cpus
@property
def maxcpus(self):
"""
Returns the maximum number of hotpluggable vCPUs for this QEMU VM.
:returns: maximum number of hotpluggable vCPUs.
"""
return self._maxcpus
@maxcpus.setter
def maxcpus(self, maxcpus):
"""
Sets the maximum number of hotpluggable vCPUs for this QEMU VM.
:param maxcpus: maximum number of hotpluggable vCPUs
"""
2021-04-13 09:07:58 +00:00
log.info(f'QEMU VM "{self._name}" [{self._id}] has set maximum number of hotpluggable vCPUs to {maxcpus}')
self._maxcpus = maxcpus
2015-02-19 10:33:25 +00:00
@property
def options(self):
"""
Returns the options for this QEMU VM.
:returns: QEMU options
"""
return self._options
@options.setter
def options(self, options):
"""
Sets the options for this QEMU VM.
:param options: QEMU options
"""
2021-04-13 09:16:50 +00:00
log.info(
'QEMU VM "{name}" [{id}] has set the QEMU options to {options}'.format(
name=self._name, id=self._id, options=options
)
)
# "-no-kvm" and "-no-hax' are deprecated since Qemu v5.2
if "-no-kvm" in options:
options = options.replace("-no-kvm", "-machine accel=tcg")
if "-no-hax" in options:
options = options.replace("-no-hax", "-machine accel=tcg")
if "-enable-kvm" in options:
if not sys.platform.startswith("linux"):
# KVM can only be enabled on Linux
2015-07-27 21:31:42 +00:00
options = options.replace("-enable-kvm", "")
else:
options = options.replace("-enable-kvm", "-machine accel=kvm")
if "-enable-hax" in options:
2022-01-19 11:58:36 +00:00
if not sys.platform.startswith("darwin"):
# HAXM is only available on macOS
options = options.replace("-enable-hax", "")
else:
options = options.replace("-enable-hax", "-machine accel=hax")
self._options = options.strip()
2015-02-19 10:33:25 +00:00
@property
def initrd(self):
"""
Returns the initrd path for this QEMU VM.
:returns: QEMU initrd path
"""
return self._initrd
@initrd.setter
def initrd(self, initrd):
"""
Sets the initrd path for this QEMU VM.
:param initrd: QEMU initrd path
"""
initrd = self.manager.get_abs_image_path(initrd, self.working_dir)
2021-04-13 09:16:50 +00:00
log.info(
'QEMU VM "{name}" [{id}] has set the QEMU initrd path to {initrd}'.format(
name=self._name, id=self._id, initrd=initrd
)
)
2019-04-15 10:05:20 +00:00
if "asa" in initrd and self._initrd != initrd:
2021-04-13 09:16:50 +00:00
self.project.emit(
"log.warning",
{
"message": "Warning ASA 8 is not supported by GNS3 and Cisco, please use ASAv instead. Depending of your hardware and OS this could not work or you could be limited to one instance. If ASA 8 is not booting their is no GNS3 solution, you must to upgrade to ASAv."
},
)
2015-02-19 10:33:25 +00:00
self._initrd = initrd
@property
def kernel_image(self):
"""
Returns the kernel image path for this QEMU VM.
:returns: QEMU kernel image path
"""
return self._kernel_image
@kernel_image.setter
def kernel_image(self, kernel_image):
"""
Sets the kernel image path for this QEMU VM.
:param kernel_image: QEMU kernel image path
"""
kernel_image = self.manager.get_abs_image_path(kernel_image, self.working_dir)
2021-04-13 09:16:50 +00:00
log.info(
'QEMU VM "{name}" [{id}] has set the QEMU kernel image path to {kernel_image}'.format(
name=self._name, id=self._id, kernel_image=kernel_image
)
)
2015-02-19 10:33:25 +00:00
self._kernel_image = kernel_image
@property
def kernel_command_line(self):
"""
Returns the kernel command line for this QEMU VM.
:returns: QEMU kernel command line
"""
return self._kernel_command_line
@kernel_command_line.setter
def kernel_command_line(self, kernel_command_line):
"""
Sets the kernel command line for this QEMU VM.
:param kernel_command_line: QEMU kernel command line
"""
2021-04-13 09:16:50 +00:00
log.info(
'QEMU VM "{name}" [{id}] has set the QEMU kernel command line to {kernel_command_line}'.format(
name=self._name, id=self._id, kernel_command_line=kernel_command_line
)
)
2015-02-19 10:33:25 +00:00
self._kernel_command_line = kernel_command_line
async def _set_process_priority(self):
2015-02-19 10:33:25 +00:00
"""
Changes the process priority
"""
2015-12-22 12:15:28 +00:00
if self._process_priority == "normal":
return
2022-01-19 11:58:36 +00:00
if self._process_priority == "realtime":
priority = -20
elif self._process_priority == "very high":
priority = -15
elif self._process_priority == "high":
priority = -5
elif self._process_priority == "low":
priority = 5
elif self._process_priority == "very low":
priority = 19
2015-02-19 10:33:25 +00:00
else:
2022-01-19 11:58:36 +00:00
priority = 0
try:
process = await asyncio.create_subprocess_exec(
"renice", "-n", str(priority), "-p", str(self._process.pid)
)
await process.wait()
except (OSError, subprocess.SubprocessError) as e:
log.error(f'Could not change process priority for QEMU VM "{self._name}": {e}')
2015-02-19 10:33:25 +00:00
def _stop_cpulimit(self):
"""
Stops the cpulimit process.
"""
2015-02-26 09:18:01 +00:00
if self._cpulimit_process and self._cpulimit_process.returncode is None:
2015-02-19 10:33:25 +00:00
self._cpulimit_process.kill()
try:
self._process.wait(3)
except subprocess.TimeoutExpired:
2021-04-13 09:07:58 +00:00
log.error(f"Could not kill cpulimit process {self._cpulimit_process.pid}")
2015-02-19 10:33:25 +00:00
def _set_cpu_throttling(self):
"""
Limits the CPU usage for current QEMU process.
"""
if not self.is_running():
return
try:
2021-04-13 09:16:50 +00:00
subprocess.Popen(
2022-01-19 11:58:36 +00:00
["cpulimit", "--lazy", f"--pid={self._process.pid}", f"--limit={self._cpu_throttling}"],
2021-04-13 09:16:50 +00:00
cwd=self.working_dir,
)
2021-04-13 09:07:58 +00:00
log.info(f"CPU throttled to {self._cpu_throttling}%")
2015-02-19 10:33:25 +00:00
except FileNotFoundError:
raise QemuError("cpulimit could not be found, please install it or deactivate CPU throttling")
except (OSError, subprocess.SubprocessError) as e:
2021-04-13 09:07:58 +00:00
raise QemuError(f"Could not throttle CPU: {e}")
2015-02-19 10:33:25 +00:00
async def create(self):
"""
Creates QEMU VM and sets proper MD5 hashes
"""
# In case user upload image manually we don't have md5 sums.
# We need generate hashes at this point, otherwise they will be generated
2021-04-17 14:04:28 +00:00
# at asdict but not on separate thread.
await cancellable_wait_run_in_executor(md5sum, self._hda_disk_image, self.working_dir)
await cancellable_wait_run_in_executor(md5sum, self._hdb_disk_image, self.working_dir)
await cancellable_wait_run_in_executor(md5sum, self._hdc_disk_image, self.working_dir)
await cancellable_wait_run_in_executor(md5sum, self._hdd_disk_image, self.working_dir)
2021-04-13 09:07:58 +00:00
super().create()
async def start(self):
2015-02-19 10:33:25 +00:00
"""
Starts this QEMU VM.
"""
async with self._execute_lock:
if self.is_running():
# resume the VM if it is paused
await self.resume()
return
2015-02-19 10:33:25 +00:00
if self._manager.config.settings.Qemu.enable_monitor:
try:
2021-04-13 09:16:50 +00:00
info = socket.getaddrinfo(
self._monitor_host, 0, socket.AF_UNSPEC, socket.SOCK_STREAM, 0, socket.AI_PASSIVE
)
if not info:
2021-04-13 09:07:58 +00:00
raise QemuError(f"getaddrinfo returns an empty list on {self._monitor_host}")
for res in info:
af, socktype, proto, _, sa = res
# let the OS find an unused port for the Qemu monitor
with socket.socket(af, socktype, proto) as sock:
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind(sa)
self._monitor = sock.getsockname()[1]
except OSError as e:
2021-04-13 09:07:58 +00:00
raise QemuError(f"Could not find free port for the Qemu monitor: {e}")
# check if there is enough RAM to run
self.check_available_ram(self.ram)
command = await self._build_command()
2022-01-19 11:58:36 +00:00
command_string = " ".join(shlex.quote(s) for s in command)
try:
2021-04-13 09:07:58 +00:00
log.info(f"Starting QEMU with: {command_string}")
self._stdout_file = os.path.join(self.working_dir, "qemu.log")
2021-04-13 09:07:58 +00:00
log.info(f"logging to {self._stdout_file}")
with open(self._stdout_file, "w", encoding="utf-8") as fd:
2021-04-13 09:07:58 +00:00
fd.write(f"Start QEMU with {command_string}\n\nExecution log:\n")
2021-04-13 09:16:50 +00:00
self.command_line = " ".join(command)
self._process = await asyncio.create_subprocess_exec(
*command, stdout=fd, stderr=subprocess.STDOUT, cwd=self.working_dir
)
2021-04-13 09:07:58 +00:00
log.info(f'QEMU VM "{self._name}" started PID={self._process.pid}')
self._command_line_changed = False
self.status = "started"
monitor_process(self._process, self._termination_callback)
except (OSError, subprocess.SubprocessError, UnicodeEncodeError) as e:
stdout = self.read_stdout()
2021-04-13 09:07:58 +00:00
log.error(f"Could not start QEMU {self.qemu_path}: {e}\n{stdout}")
raise QemuError(f"Could not start QEMU {self.qemu_path}: {e}\n{stdout}")
await self._set_process_priority()
if self._cpu_throttling:
self._set_cpu_throttling()
if "-enable-kvm" in command_string or "-enable-hax" in command_string:
self._hw_virtualization = True
await self._start_ubridge()
set_link_commands = []
for adapter_number, adapter in enumerate(self._ethernet_adapters):
nio = adapter.get_nio(0)
if nio:
2021-04-13 09:16:50 +00:00
await self.add_ubridge_udp_connection(
f"QEMU-{self._id}-{adapter_number}", self._local_udp_tunnels[adapter_number][1], nio
)
if nio.suspend and self._replicate_network_connection_state:
2021-04-13 09:07:58 +00:00
set_link_commands.append(f"set_link gns3-{adapter_number} off")
elif self._replicate_network_connection_state:
2021-04-13 09:07:58 +00:00
set_link_commands.append(f"set_link gns3-{adapter_number} off")
if "-loadvm" not in command_string and self._replicate_network_connection_state:
# only set the link statuses if not restoring a previous VM state
await self._control_vm_commands(set_link_commands)
try:
if self.is_running():
await self.start_wrap_console()
except OSError as e:
2021-04-13 09:07:58 +00:00
raise QemuError(f"Could not start Telnet QEMU console {e}\n")
async def _termination_callback(self, returncode):
"""
2015-05-13 19:53:42 +00:00
Called when the process has stopped.
:param returncode: Process returncode
"""
2015-05-13 19:53:42 +00:00
if self.started:
2015-05-13 19:53:42 +00:00
log.info("QEMU process has stopped, return code: %d", returncode)
await self.stop()
2022-01-19 11:58:36 +00:00
if returncode != 0:
2021-04-13 09:16:50 +00:00
self.project.emit(
"log.error",
{"message": f"QEMU process has stopped, return code: {returncode}\n{self.read_stdout()}"},
)
async def stop(self):
2015-02-19 10:33:25 +00:00
"""
Stops this QEMU VM.
"""
await self._stop_ubridge()
async with self._execute_lock:
# stop the QEMU process
self._hw_virtualization = False
if self.is_running():
2021-04-13 09:07:58 +00:00
log.info(f'Stopping QEMU VM "{self._name}" PID={self._process.pid}')
try:
if self.on_close == "save_vm_state":
await self._control_vm("stop")
await self._control_vm("savevm GNS3_SAVED_STATE")
wait_for_savevm = 120
while wait_for_savevm:
await asyncio.sleep(1)
status = await self._saved_state_option()
wait_for_savevm -= 1
if status != []:
break
if self.on_close == "shutdown_signal":
await self._control_vm("system_powerdown")
2019-03-01 10:23:49 +00:00
await gns3server.utils.asyncio.wait_for_process_termination(self._process, timeout=120)
else:
self._process.terminate()
await gns3server.utils.asyncio.wait_for_process_termination(self._process, timeout=3)
except ProcessLookupError:
pass
except asyncio.TimeoutError:
if self._process:
try:
self._process.kill()
except ProcessLookupError:
pass
if self._process.returncode is None:
2021-04-13 09:07:58 +00:00
log.warning(f'QEMU VM "{self._name}" PID={self._process.pid} is still running')
self._process = None
self._stop_cpulimit()
if self.on_close != "save_vm_state":
await self._clear_save_vm_stated()
await self._export_config()
await super().stop()
2015-02-19 10:33:25 +00:00
async def _open_qemu_monitor_connection_vm(self, timeout=10):
"""
Opens a connection to the QEMU monitor.
:param timeout: timeout to connect to the monitor TCP server
:returns: The reader returned is a StreamReader instance; the writer is a StreamWriter instance
"""
begin = time.time()
connection_success = False
last_exception = None
reader = writer = None
while time.time() - begin < timeout:
await asyncio.sleep(0.01)
try:
2021-04-13 09:07:58 +00:00
log.debug(f"Connecting to Qemu monitor on {self._monitor_host}:{self._monitor}")
reader, writer = await asyncio.open_connection(self._monitor_host, self._monitor)
except (asyncio.TimeoutError, OSError) as e:
last_exception = e
continue
connection_success = True
break
if not connection_success:
2021-04-13 09:16:50 +00:00
log.warning(
"Could not connect to QEMU monitor on {}:{}: {}".format(
self._monitor_host, self._monitor, last_exception
)
)
else:
2021-04-13 09:16:50 +00:00
log.info(
f"Connected to QEMU monitor on {self._monitor_host}:{self._monitor} after {time.time() - begin:.4f} seconds"
)
return reader, writer
async def _control_vm(self, command, expected=None):
2015-02-19 10:33:25 +00:00
"""
Executes a command with QEMU monitor when this VM is running.
:param command: QEMU monitor command (e.g. info status, stop etc.)
2015-04-08 17:17:34 +00:00
:param expected: An array of expected strings
2015-02-19 10:33:25 +00:00
2015-04-08 17:17:34 +00:00
:returns: result of the command (matched object or None)
2015-02-19 10:33:25 +00:00
"""
result = None
if self.is_running() and self._monitor:
2021-04-13 09:07:58 +00:00
log.info(f"Execute QEMU monitor command: {command}")
reader, writer = await self._open_qemu_monitor_connection_vm()
if reader is None and writer is None:
2015-02-19 10:33:25 +00:00
return result
2015-02-19 10:33:25 +00:00
try:
2021-04-13 09:16:50 +00:00
cmd_byte = command.encode("ascii")
writer.write(cmd_byte + b"\n")
if not expected:
while True:
line = await asyncio.wait_for(reader.readline(), timeout=3) # echo of the command
if not line or cmd_byte in line:
break
except asyncio.TimeoutError:
2021-04-13 09:07:58 +00:00
log.warning(f"Missing echo of command '{command}'")
2015-02-19 10:33:25 +00:00
except OSError as e:
2021-04-13 09:07:58 +00:00
log.warning(f"Could not write to QEMU monitor: {e}")
2015-02-20 23:15:56 +00:00
writer.close()
2015-02-19 10:33:25 +00:00
return result
if expected:
try:
2015-02-20 23:15:56 +00:00
while result is None:
line = await asyncio.wait_for(reader.readline(), timeout=3)
2015-02-20 23:15:56 +00:00
if not line:
break
for expect in expected:
if expect in line:
2015-04-27 03:19:39 +00:00
result = line.decode("utf-8").strip()
2015-02-20 23:15:56 +00:00
break
except asyncio.TimeoutError:
2021-04-13 09:07:58 +00:00
log.warning(f"Timeout while waiting for result of command '{command}'")
except (ConnectionError, EOFError) as e:
2021-04-13 09:07:58 +00:00
log.warning(f"Could not read from QEMU monitor: {e}")
2015-02-20 23:15:56 +00:00
writer.close()
2015-02-19 10:33:25 +00:00
return result
async def _control_vm_commands(self, commands):
"""
Executes commands with QEMU monitor when this VM is running.
:param commands: a list of QEMU monitor commands (e.g. info status, stop etc.)
"""
if self.is_running() and self._monitor:
reader, writer = await self._open_qemu_monitor_connection_vm()
if reader is None and writer is None:
return
for command in commands:
2021-04-13 09:07:58 +00:00
log.info(f"Execute QEMU monitor command: {command}")
try:
2021-04-13 09:16:50 +00:00
cmd_byte = command.encode("ascii")
writer.write(cmd_byte + b"\n")
while True:
line = await asyncio.wait_for(reader.readline(), timeout=3) # echo of the command
if not line or cmd_byte in line:
break
except asyncio.TimeoutError:
2021-04-13 09:07:58 +00:00
log.warning(f"Missing echo of command '{command}'")
except OSError as e:
2021-04-13 09:07:58 +00:00
log.warning(f"Could not write to QEMU monitor: {e}")
writer.close()
async def close(self):
2015-04-08 17:17:34 +00:00
"""
Closes this QEMU VM.
"""
if not (await super().close()):
return False
2021-04-13 09:16:50 +00:00
# FIXME: Don't wait for ACPI shutdown when closing the project, should we?
if self.on_close == "shutdown_signal":
self.on_close = "power_off"
await self.stop()
for adapter in self._ethernet_adapters:
if adapter is not None:
for nio in adapter.ports.values():
if nio and isinstance(nio, NIOUDP):
self.manager.port_manager.release_udp_port(nio.lport, self._project)
for udp_tunnel in self._local_udp_tunnels.values():
self.manager.port_manager.release_udp_port(udp_tunnel[0].lport, self._project)
self.manager.port_manager.release_udp_port(udp_tunnel[1].lport, self._project)
self._local_udp_tunnels = {}
async def _get_vm_status(self):
2015-02-19 10:33:25 +00:00
"""
2015-04-08 17:17:34 +00:00
Returns this VM suspend status.
2015-02-19 10:33:25 +00:00
2015-03-17 10:02:14 +00:00
Status are extracted from:
https://github.com/qemu/qemu/blob/master/qapi-schema.json#L152
2015-02-19 10:33:25 +00:00
:returns: status (string)
"""
2021-04-13 09:16:50 +00:00
result = await self._control_vm(
"info status",
[
b"debug",
b"inmigrate",
b"internal-error",
b"io-error",
b"paused",
b"postmigrate",
b"prelaunch",
b"finish-migrate",
b"restore-vm",
b"running",
b"save-vm",
b"shutdown",
b"suspended",
b"watchdog",
b"guest-panicked",
],
)
if result is None:
return result
2021-04-13 09:16:50 +00:00
status = result.rsplit(" ", 1)[1]
if status == "running" or status == "prelaunch":
self.status = "started"
elif status == "suspended":
self.status = "suspended"
elif status == "shutdown":
self.status = "stopped"
return status
2015-02-19 10:33:25 +00:00
async def suspend(self):
2015-02-19 10:33:25 +00:00
"""
Suspends this QEMU VM.
"""
if self.is_running():
vm_status = await self._get_vm_status()
if vm_status is None:
raise QemuError("Suspending a QEMU VM is not supported")
elif vm_status == "running" or vm_status == "prelaunch":
await self._control_vm("stop")
self.status = "suspended"
log.debug("QEMU VM has been suspended")
else:
2021-04-13 09:07:58 +00:00
log.info(f"QEMU VM is not running to be suspended, current status is {vm_status}")
2015-02-19 10:33:25 +00:00
async def reload(self):
2015-02-19 10:33:25 +00:00
"""
Reloads this QEMU VM.
"""
if self._command_line_changed:
await self.stop()
await self.start()
else:
await self._control_vm("system_reset")
2015-02-19 10:33:25 +00:00
log.debug("QEMU VM has been reset")
async def resume(self):
2015-02-19 10:33:25 +00:00
"""
Resumes this QEMU VM.
"""
vm_status = await self._get_vm_status()
if vm_status is None:
raise QemuError("Resuming a QEMU VM is not supported")
elif vm_status == "paused":
await self._control_vm("cont")
self.status = "started"
2015-02-19 10:33:25 +00:00
log.debug("QEMU VM has been resumed")
else:
2021-04-13 09:07:58 +00:00
log.info(f"QEMU VM is not paused to be resumed, current status is {vm_status}")
2015-02-19 10:33:25 +00:00
async def adapter_add_nio_binding(self, adapter_number, nio):
2015-02-19 10:33:25 +00:00
"""
Adds an adapter NIO binding.
2015-02-19 10:33:25 +00:00
2015-04-08 17:17:34 +00:00
:param adapter_number: adapter number
2015-03-07 03:08:00 +00:00
:param nio: NIO instance to add to the adapter
2015-02-19 10:33:25 +00:00
"""
try:
2015-04-08 17:17:34 +00:00
adapter = self._ethernet_adapters[adapter_number]
2015-02-19 10:33:25 +00:00
except IndexError:
2021-04-13 09:16:50 +00:00
raise QemuError(
'Adapter {adapter_number} does not exist on QEMU VM "{name}"'.format(
name=self._name, adapter_number=adapter_number
)
)
2015-02-19 10:33:25 +00:00
2017-07-12 08:07:21 +00:00
if self.is_running():
try:
2021-04-13 09:16:50 +00:00
await self.add_ubridge_udp_connection(
f"QEMU-{self._id}-{adapter_number}", self._local_udp_tunnels[adapter_number][1], nio
)
if self._replicate_network_connection_state:
2021-04-13 09:07:58 +00:00
await self._control_vm(f"set_link gns3-{adapter_number} on")
except (IndexError, KeyError):
2021-04-13 09:16:50 +00:00
raise QemuError(
'Adapter {adapter_number} does not exist on QEMU VM "{name}"'.format(
name=self._name, adapter_number=adapter_number
)
)
2015-02-19 10:33:25 +00:00
adapter.add_nio(0, nio)
2021-04-13 09:16:50 +00:00
log.info(
'QEMU VM "{name}" [{id}]: {nio} added to adapter {adapter_number}'.format(
name=self._name, id=self._id, nio=nio, adapter_number=adapter_number
)
)
async def adapter_update_nio_binding(self, adapter_number, nio):
"""
Update an adapter NIO binding.
:param adapter_number: adapter number
:param nio: NIO instance to update the adapter
"""
if self.is_running():
try:
2021-04-13 09:16:50 +00:00
await self.update_ubridge_udp_connection(
f"QEMU-{self._id}-{adapter_number}", self._local_udp_tunnels[adapter_number][1], nio
)
if self._replicate_network_connection_state:
if nio.suspend:
2021-04-13 09:07:58 +00:00
await self._control_vm(f"set_link gns3-{adapter_number} off")
else:
2021-04-13 09:07:58 +00:00
await self._control_vm(f"set_link gns3-{adapter_number} on")
except IndexError:
2021-04-13 09:16:50 +00:00
raise QemuError(
'Adapter {adapter_number} does not exist on QEMU VM "{name}"'.format(
name=self._name, adapter_number=adapter_number
)
)
2015-02-19 10:33:25 +00:00
async def adapter_remove_nio_binding(self, adapter_number):
2015-02-19 10:33:25 +00:00
"""
Removes an adapter NIO binding.
2015-02-19 10:33:25 +00:00
2015-04-08 17:17:34 +00:00
:param adapter_number: adapter number
2015-02-19 10:33:25 +00:00
:returns: NIO instance
"""
try:
2015-04-08 17:17:34 +00:00
adapter = self._ethernet_adapters[adapter_number]
2015-02-19 10:33:25 +00:00
except IndexError:
2021-04-13 09:16:50 +00:00
raise QemuError(
'Adapter {adapter_number} does not exist on QEMU VM "{name}"'.format(
name=self._name, adapter_number=adapter_number
)
)
2015-02-19 10:33:25 +00:00
await self.stop_capture(adapter_number)
2017-07-12 08:07:21 +00:00
if self.is_running():
if self._replicate_network_connection_state:
2021-04-13 09:07:58 +00:00
await self._control_vm(f"set_link gns3-{adapter_number} off")
await self._ubridge_send("bridge delete {name}".format(name=f"QEMU-{self._id}-{adapter_number}"))
2015-02-19 10:33:25 +00:00
nio = adapter.get_nio(0)
2015-03-07 03:08:00 +00:00
if isinstance(nio, NIOUDP):
self.manager.port_manager.release_udp_port(nio.lport, self._project)
2015-02-19 10:33:25 +00:00
adapter.remove_nio(0)
2021-04-13 09:16:50 +00:00
log.info(
'QEMU VM "{name}" [{id}]: {nio} removed from adapter {adapter_number}'.format(
name=self._name, id=self._id, nio=nio, adapter_number=adapter_number
)
)
2015-02-19 10:33:25 +00:00
return nio
def get_nio(self, adapter_number):
"""
Gets an adapter NIO binding.
:param adapter_number: adapter number
:returns: NIO instance
"""
try:
adapter = self._ethernet_adapters[adapter_number]
except IndexError:
2021-04-13 09:16:50 +00:00
raise QemuError(
'Adapter {adapter_number} does not exist on QEMU VM "{name}"'.format(
name=self._name, adapter_number=adapter_number
)
)
nio = adapter.get_nio(0)
if not nio:
2021-04-13 09:07:58 +00:00
raise QemuError(f"Adapter {adapter_number} is not connected")
return nio
async def start_capture(self, adapter_number, output_file):
"""
Starts a packet capture.
:param adapter_number: adapter number
:param output_file: PCAP destination file for the capture
"""
nio = self.get_nio(adapter_number)
if nio.capturing:
2021-04-13 09:07:58 +00:00
raise QemuError(f"Packet capture is already activated on adapter {adapter_number}")
nio.start_packet_capture(output_file)
if self.ubridge:
2021-04-13 09:16:50 +00:00
await self._ubridge_send(
'bridge start_capture {name} "{output_file}"'.format(
name=f"QEMU-{self._id}-{adapter_number}", output_file=output_file
)
)
log.info(
"QEMU VM '{name}' [{id}]: starting packet capture on adapter {adapter_number}".format(
name=self.name, id=self.id, adapter_number=adapter_number
)
)
async def stop_capture(self, adapter_number):
"""
Stops a packet capture.
:param adapter_number: adapter number
"""
nio = self.get_nio(adapter_number)
if not nio.capturing:
return
nio.stop_packet_capture()
if self.ubridge:
2021-04-13 09:16:50 +00:00
await self._ubridge_send("bridge stop_capture {name}".format(name=f"QEMU-{self._id}-{adapter_number}"))
2021-04-13 09:16:50 +00:00
log.info(
"QEMU VM '{name}' [{id}]: stopping packet capture on adapter {adapter_number}".format(
name=self.name, id=self.id, adapter_number=adapter_number
)
)
async def create_disk_image(self, disk_name, options):
"""
Create a Qemu disk
:param disk_name: disk name
:param options: disk creation options
"""
try:
qemu_img_path = self._get_qemu_img()
img_format = options.pop("format")
img_size = options.pop("size")
disk_path = os.path.join(self.working_dir, disk_name)
try:
if os.path.exists(disk_path):
raise QemuError(f"Could not create disk image '{disk_name}', file already exists")
except UnicodeEncodeError:
raise QemuError(
f"Could not create disk image '{disk_name}', "
"Disk image name contains characters not supported by the filesystem"
)
command = [qemu_img_path, "create", "-f", img_format]
for option in sorted(options.keys()):
command.extend(["-o", f"{option}={options[option]}"])
command.append(disk_path)
command.append(f"{img_size}M")
retcode = await self._qemu_img_exec(command)
if retcode:
stdout = self.read_qemu_img_stdout()
raise QemuError(f"Could not create '{disk_name}' disk image: qemu-img returned with {retcode}\n{stdout}")
else:
log.info(f"QEMU VM '{self.name}' [{self.id}]: Qemu disk image'{disk_name}' created")
except (OSError, subprocess.SubprocessError) as e:
stdout = self.read_qemu_img_stdout()
raise QemuError(f"Could not create '{disk_name}' disk image: {e}\n{stdout}")
async def resize_disk_image(self, disk_name, extend):
"""
Resize a Qemu disk
:param disk_name: disk name
:param extend: new size
"""
try:
qemu_img_path = self._get_qemu_img()
disk_path = os.path.join(self.working_dir, disk_name)
if not os.path.exists(disk_path):
raise QemuError(f"Qemu disk image '{disk_name}' does not exist")
command = [qemu_img_path, "resize", disk_path, f"+{extend}M"]
retcode = await self._qemu_img_exec(command)
if retcode:
stdout = self.read_qemu_img_stdout()
raise QemuError(f"Could not update '{disk_name}' disk image: qemu-img returned with {retcode}\n{stdout}")
else:
log.info(f"QEMU VM '{self.name}' [{self.id}]: Qemu disk image '{disk_name}' extended by {extend} MB")
except (OSError, subprocess.SubprocessError) as e:
stdout = self.read_qemu_img_stdout()
raise QemuError(f"Could not update '{disk_name}' disk image: {e}\n{stdout}")
def delete_disk_image(self, disk_name):
"""
Delete a Qemu disk
:param disk_name: disk name
"""
disk_path = os.path.join(self.working_dir, disk_name)
if not os.path.exists(disk_path):
raise QemuError(f"Qemu disk image '{disk_name}' does not exist")
try:
os.remove(disk_path)
except OSError as e:
raise QemuError(f"Could not delete '{disk_name}' disk image: {e}")
2015-02-19 10:33:25 +00:00
@property
def started(self):
"""
Returns either this QEMU VM has been started or not.
:returns: boolean
"""
return self.status == "started"
2015-02-19 10:33:25 +00:00
def read_stdout(self):
"""
Reads the standard output of the QEMU process.
Only use when the process has been stopped or has crashed.
"""
output = ""
if self._stdout_file:
try:
with open(self._stdout_file, "rb") as file:
output = file.read().decode("utf-8", errors="replace")
2015-02-19 10:33:25 +00:00
except OSError as e:
2021-04-13 09:07:58 +00:00
log.warning(f"Could not read {self._stdout_file}: {e}")
return output
def read_qemu_img_stdout(self):
"""
Reads the standard output of the QEMU-IMG process.
"""
output = ""
if self._qemu_img_stdout_file:
try:
with open(self._qemu_img_stdout_file, "rb") as file:
output = file.read().decode("utf-8", errors="replace")
except OSError as e:
2021-04-13 09:07:58 +00:00
log.warning(f"Could not read {self._qemu_img_stdout_file}: {e}")
2015-02-19 10:33:25 +00:00
return output
def is_running(self):
"""
Checks if the QEMU process is running
:returns: True or False
"""
if self._process:
if self._process.returncode is None:
return True
else:
self._process = None
2015-02-19 10:33:25 +00:00
return False
def command(self):
"""
Returns the QEMU command line.
:returns: QEMU command line (string)
"""
return " ".join(self._build_command())
2018-03-24 11:11:21 +00:00
@BaseNode.console_type.setter
def console_type(self, new_console_type):
"""
Sets the console type for this QEMU VM.
:param new_console_type: console type (string)
"""
if self.is_running() and self.console_type != new_console_type:
2021-04-13 09:07:58 +00:00
raise QemuError(f'"{self._name}" must be stopped to change the console type to {new_console_type}')
2018-03-24 11:11:21 +00:00
super(QemuVM, QemuVM).console_type.__set__(self, new_console_type)
def _serial_options(self, internal_console_port, external_console_port):
2015-02-19 10:33:25 +00:00
if external_console_port:
2021-04-13 09:07:58 +00:00
return ["-serial", f"telnet:127.0.0.1:{internal_console_port},server,nowait"]
2015-02-19 10:33:25 +00:00
else:
return []
def _vnc_options(self, port):
2015-06-25 01:09:17 +00:00
if port:
vnc_port = port - 5900 # subtract by 5900 to get the display number
2021-04-13 09:07:58 +00:00
return ["-vnc", f"{self._manager.port_manager.console_host}:{vnc_port}"]
2015-06-25 01:09:17 +00:00
else:
return []
def _spice_options(self, port):
if port:
console_host = self._manager.port_manager.console_host
if console_host == "0.0.0.0":
if socket.has_ipv6:
# to fix an issue with Qemu when IPv4 is not enabled
# see https://github.com/GNS3/gns3-gui/issues/2352
# FIXME: consider making this more global (not just for Qemu + SPICE)
console_host = "::"
else:
raise QemuError("IPv6 must be enabled in order to use the SPICE console")
2021-04-13 09:16:50 +00:00
return ["-spice", f"addr={console_host},port={port},disable-ticketing", "-vga", "qxl"]
else:
return []
def _spice_with_agent_options(self, port):
2018-03-25 07:36:14 +00:00
spice_options = self._spice_options(port)
if spice_options:
2018-03-25 07:36:14 +00:00
# agent options (mouse/screen)
2021-04-13 09:16:50 +00:00
agent_options = [
"-device",
"virtio-serial",
"-chardev",
"spicevmc,id=vdagent,debug=0,name=vdagent",
"-device",
"virtserialport,chardev=vdagent,name=com.redhat.spice.0",
]
2018-03-25 07:36:14 +00:00
spice_options.extend(agent_options)
# folder sharing options
2021-04-13 09:16:50 +00:00
folder_sharing_options = [
"-chardev",
"spiceport,name=org.spice-space.webdav.0,id=charchannel0",
"-device",
"virtserialport,chardev=charchannel0,id=channel0,name=org.spice-space.webdav.0",
]
2018-03-25 07:36:14 +00:00
spice_options.extend(folder_sharing_options)
return spice_options
def _console_options(self):
if self._console_type == "telnet" and self._wrap_console:
return self._serial_options(self._internal_console_port, self.console)
elif self._console_type == "vnc":
return self._vnc_options(self.console)
elif self._console_type == "spice":
return self._spice_options(self.console)
elif self._console_type == "spice+agent":
return self._spice_with_agent_options(self.console)
elif self._console_type != "none":
2021-04-13 09:07:58 +00:00
raise QemuError(f"Console type {self._console_type} is unknown")
def _aux_options(self):
if self._aux_type != "none" and self._aux_type == self._console_type:
2021-04-13 09:07:58 +00:00
raise QemuError(f"Auxiliary console type {self._aux_type} cannot be the same as console type")
if self._aux_type == "telnet" and self._wrap_aux:
return self._serial_options(self._internal_aux_port, self.aux)
elif self._aux_type == "vnc":
return self._vnc_options(self.aux)
elif self._aux_type == "spice":
return self._spice_options(self.aux)
elif self._aux_type == "spice+agent":
return self._spice_with_agent_options(self.aux)
elif self._aux_type != "none":
2021-04-13 09:07:58 +00:00
raise QemuError(f"Auxiliary console type {self._aux_type} is unknown")
return []
2015-02-19 10:33:25 +00:00
def _monitor_options(self):
if self._monitor:
2021-04-13 09:07:58 +00:00
return ["-monitor", f"tcp:{self._monitor_host}:{self._monitor},server,nowait"]
2015-02-19 10:33:25 +00:00
else:
return []
def _get_qemu_img(self):
"""
Search the qemu-img binary in the same binary of the qemu binary
to avoid version incompatibility.
:returns: qemu-img path or raise an error
"""
2015-02-19 10:33:25 +00:00
qemu_path_dir = os.path.dirname(self.qemu_path)
qemu_image_path = shutil.which("qemu-img", path=qemu_path_dir)
if qemu_image_path:
return qemu_image_path
raise QemuError(f"Could not find qemu-img in {qemu_path_dir}")
async def _qemu_img_exec(self, command):
self._qemu_img_stdout_file = os.path.join(self.working_dir, "qemu-img.log")
2021-04-13 09:07:58 +00:00
log.info(f"logging to {self._qemu_img_stdout_file}")
2022-01-19 11:58:36 +00:00
command_string = " ".join(shlex.quote(s) for s in command)
2021-04-13 09:07:58 +00:00
log.info(f"Executing qemu-img with: {command_string}")
with open(self._qemu_img_stdout_file, "w", encoding="utf-8") as fd:
2021-04-13 09:16:50 +00:00
process = await asyncio.create_subprocess_exec(
*command, stdout=fd, stderr=subprocess.STDOUT, cwd=self.working_dir
)
retcode = await process.wait()
if retcode != 0:
log.info(f"{self._get_qemu_img()} returned with {retcode}")
return retcode
async def _find_disk_file_format(self, disk):
qemu_img_path = self._get_qemu_img()
try:
output = await subprocess_check_output(qemu_img_path, "info", "--output=json", disk)
except subprocess.SubprocessError as e:
raise QemuError(f"Error received while checking Qemu disk format: {e}")
if output:
try:
json_data = json.loads(output)
except ValueError as e:
raise QemuError(f"Invalid JSON data returned by qemu-img: {e}")
return json_data.get("format")
async def _create_linked_clone(self, disk_name, disk_image, disk):
try:
qemu_img_path = self._get_qemu_img()
backing_file_format = await self._find_disk_file_format(disk_image)
if not backing_file_format:
raise QemuError(f"Could not detect format for disk image: {disk_image}")
backing_options, base_qcow2 = Qcow2.backing_options(disk_image)
if base_qcow2 and base_qcow2.crypt_method:
# Workaround for https://gitlab.com/qemu-project/qemu/-/issues/441
# (we have to pass -u and the size). Also embed secret name.
command = [qemu_img_path, "create", "-b", backing_options,
"-F", backing_file_format, "-f", "qcow2", "-u", disk, str(base_qcow2.size)]
else:
command = [qemu_img_path, "create", "-o", "backing_file={}".format(disk_image),
"-F", backing_file_format, "-f", "qcow2", disk]
retcode = await self._qemu_img_exec(command)
if retcode:
stdout = self.read_qemu_img_stdout()
2021-04-13 09:16:50 +00:00
raise QemuError(
"Could not create '{}' disk image: qemu-img returned with {}\n{}".format(disk_name, retcode, stdout)
)
except (OSError, subprocess.SubprocessError) as e:
stdout = self.read_qemu_img_stdout()
2021-04-13 09:07:58 +00:00
raise QemuError(f"Could not create '{disk_name}' disk image: {e}\n{stdout}")
2020-04-15 18:50:59 +00:00
async def _mcopy(self, image, *args):
try:
2020-04-15 18:50:59 +00:00
# read offset of first partition from MBR
with open(image, "rb") as img_file:
mbr = img_file.read(512)
part_type, offset, signature = struct.unpack("<450xB3xL52xH", mbr)
if signature != 0xAA55:
2021-04-13 09:07:58 +00:00
raise OSError(f"mcopy failure: {image}: invalid MBR")
2020-04-15 18:50:59 +00:00
if part_type not in (1, 4, 6, 11, 12, 14):
2021-04-13 09:16:50 +00:00
raise OSError("mcopy failure: {}: invalid partition type {:02X}".format(image, part_type))
2021-04-13 09:07:58 +00:00
part_image = image + f"@@{offset}S"
2020-04-15 18:50:59 +00:00
process = await asyncio.create_subprocess_exec(
2021-04-13 09:16:50 +00:00
"mcopy",
"-i",
part_image,
*args,
2020-04-15 18:50:59 +00:00
stdin=subprocess.DEVNULL,
2021-04-13 09:16:50 +00:00
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
cwd=self.working_dir,
)
(stdout, _) = await process.communicate()
retcode = process.returncode
except (OSError, subprocess.SubprocessError) as e:
2021-04-13 09:07:58 +00:00
raise OSError(f"mcopy failure: {e}")
if retcode != 0:
stdout = stdout.decode("utf-8").rstrip()
if stdout:
2021-04-13 09:07:58 +00:00
raise OSError(f"mcopy failure: {stdout}")
else:
2021-04-13 09:07:58 +00:00
raise OSError(f"mcopy failure: return code {retcode}")
async def _export_config(self):
disk_name = getattr(self, "config_disk_name")
2020-04-15 18:50:59 +00:00
if not disk_name:
return
disk = os.path.join(self.working_dir, disk_name)
if not os.path.exists(disk):
return
config_dir = os.path.join(self.working_dir, "configs")
zip_file = os.path.join(self.working_dir, "config.zip")
try:
os.mkdir(config_dir)
await self._mcopy(disk, "-s", "-m", "-n", "--", "::/", config_dir)
if os.path.exists(zip_file):
os.remove(zip_file)
pack_zip(zip_file, config_dir)
except OSError as e:
2021-04-13 09:07:58 +00:00
log.warning(f"Can't export config: {e}")
self.project.emit("log.warning", {"message": f"{self._name}: Can't export config: {e}"})
shutil.rmtree(config_dir, ignore_errors=True)
async def _import_config(self):
disk_name = getattr(self, "config_disk_name")
zip_file = os.path.join(self.working_dir, "config.zip")
if not disk_name or not os.path.exists(zip_file):
return
config_dir = os.path.join(self.working_dir, "configs")
disk = os.path.join(self.working_dir, disk_name)
disk_tmp = disk + ".tmp"
try:
os.mkdir(config_dir)
shutil.copyfile(getattr(self, "config_disk_image"), disk_tmp)
unpack_zip(zip_file, config_dir)
2021-04-13 09:16:50 +00:00
config_files = [os.path.join(config_dir, fname) for fname in os.listdir(config_dir)]
if config_files:
await self._mcopy(disk_tmp, "-s", "-m", "-o", "--", *config_files, "::/")
os.replace(disk_tmp, disk)
except OSError as e:
2021-04-13 09:07:58 +00:00
log.warning(f"Can't import config: {e}")
self.project.emit("log.warning", {"message": f"{self._name}: Can't import config: {e}"})
if os.path.exists(disk_tmp):
os.remove(disk_tmp)
os.remove(zip_file)
shutil.rmtree(config_dir, ignore_errors=True)
2021-02-18 07:44:35 +00:00
async def _disk_interface_options(self, disk, disk_index, interface, format=None):
options = []
extra_drive_options = ""
if format:
2021-04-13 09:07:58 +00:00
extra_drive_options += f",format={format}"
# From Qemu man page: if the filename contains comma, you must double it
# (for instance, "file=my,,file" to use file "my,file").
disk = disk.replace(",", ",,")
if interface == "sata":
# special case, sata controller doesn't exist in Qemu
2021-04-13 09:16:50 +00:00
options.extend(["-device", f"ahci,id=ahci{disk_index}"])
options.extend(
[
"-drive",
f"file={disk},if=none,id=drive{disk_index},index={disk_index},media=disk{extra_drive_options}",
]
)
qemu_version = await self.manager.get_qemu_version(self.qemu_path)
if qemu_version and parse_version(qemu_version) >= parse_version("4.2.0"):
# The ide-drive device is deprecated since version 4.2.0
# https://qemu.readthedocs.io/en/latest/system/deprecated.html#ide-drive-since-4-2
2021-04-13 09:16:50 +00:00
options.extend(
["-device", f"ide-hd,drive=drive{disk_index},bus=ahci{disk_index}.0,id=drive{disk_index}"]
)
else:
2021-04-13 09:16:50 +00:00
options.extend(
["-device", f"ide-drive,drive=drive{disk_index},bus=ahci{disk_index}.0,id=drive{disk_index}"]
)
elif interface == "nvme":
2021-04-13 09:16:50 +00:00
options.extend(
[
"-drive",
f"file={disk},if=none,id=drive{disk_index},index={disk_index},media=disk{extra_drive_options}",
]
)
options.extend(["-device", f"nvme,drive=drive{disk_index},serial={disk_index}"])
elif interface == "scsi":
2021-04-13 09:16:50 +00:00
options.extend(["-device", f"virtio-scsi-pci,id=scsi{disk_index}"])
options.extend(
[
"-drive",
f"file={disk},if=none,id=drive{disk_index},index={disk_index},media=disk{extra_drive_options}",
]
)
options.extend(["-device", f"scsi-hd,drive=drive{disk_index}"])
# elif interface == "sd":
# options.extend(["-drive", 'file={},id=drive{},index={}{}'.format(disk, disk_index, disk_index, extra_drive_options)])
# options.extend(["-device", 'sd-card,drive=drive{},id=drive{}'.format(disk_index, disk_index, disk_index)])
else:
2021-04-13 09:16:50 +00:00
options.extend(
[
"-drive",
f"file={disk},if={interface},index={disk_index},media=disk,id=drive{disk_index}{extra_drive_options}",
]
)
return options
async def _disk_options(self):
options = []
qemu_img_path = self._get_qemu_img()
drives = ["a", "b", "c", "d"]
for disk_index, drive in enumerate(drives):
# prioritize config disk over normal disks
2021-04-13 09:16:50 +00:00
if drive == "d" and self._create_config_disk:
continue
2021-04-13 09:07:58 +00:00
disk_image = getattr(self, f"_hd{drive}_disk_image")
if not disk_image:
continue
2021-04-13 09:07:58 +00:00
interface = getattr(self, f"hd{drive}_disk_interface")
# fail-safe: use "ide" if there is a disk image and no interface type has been explicitly configured
if interface == "none":
2020-08-15 07:05:31 +00:00
interface = "ide"
2021-04-13 09:07:58 +00:00
setattr(self, f"hd{drive}_disk_interface", interface)
disk_name = f"hd{drive}"
if not os.path.isfile(disk_image) or not os.path.exists(disk_image):
if os.path.islink(disk_image):
2021-04-13 09:16:50 +00:00
raise QemuError(
f"'{disk_name}' disk image linked to "
f"'{os.path.realpath(disk_image)}' is not accessible"
2021-04-13 09:16:50 +00:00
)
else:
raise QemuError(f"'{disk_image}' is not accessible")
else:
try:
# check for corrupt disk image
retcode = await self._qemu_img_exec([qemu_img_path, "check", disk_image])
# ignore retcode == 1, one reason is that the image is encrypted and
# there is no encrypt.key-secret available
if retcode == 3:
# image has leaked clusters, but is not corrupted, let's try to fix it
log.warning(f"Disk image '{disk_image}' has leaked clusters")
if await self._qemu_img_exec([qemu_img_path, "check", "-r", "leaks", f"{disk_image}"]) == 3:
self.project.emit(
"log.warning",
{"message": f"Disk image '{disk_image}' has leaked clusters and could not be fixed"}
)
elif retcode == 2:
# image is corrupted, let's try to fix it
log.warning(f"Disk image '{disk_image}' is corrupted")
if await self._qemu_img_exec([qemu_img_path, "check", "-r", "all", f"{disk_image}"]) == 2:
self.project.emit(
"log.warning",
{"message": f"Disk image '{disk_image}' is corrupted and could not be fixed"}
)
except (OSError, subprocess.SubprocessError) as e:
stdout = self.read_qemu_img_stdout()
2021-04-13 09:07:58 +00:00
raise QemuError(f"Could not check '{disk_name}' disk image: {e}\n{stdout}")
if self.linked_clone and os.path.dirname(disk_image) != self.working_dir:
#cloned_disk_image = os.path.splitext(os.path.basename(disk_image))
2021-04-13 09:07:58 +00:00
disk = os.path.join(self.working_dir, f"{disk_name}_disk.qcow2")
if not os.path.exists(disk):
# create the disk
await self._create_linked_clone(disk_name, disk_image, disk)
else:
backing_file_format = await self._find_disk_file_format(disk_image)
if not backing_file_format:
raise QemuError(f"Could not detect format for disk image '{disk_image}'")
# Rebase the image. This is in case the base image moved to a different directory,
# which will be the case if we imported a portable project. This uses
# get_abs_image_path(hdX_disk_image) and ignores the old base path embedded
# in the qcow2 file itself.
try:
qcow2 = Qcow2(disk)
await qcow2.rebase(qemu_img_path, disk_image, backing_file_format)
except (Qcow2Error, OSError) as e:
2021-04-13 09:07:58 +00:00
raise QemuError(f"Could not use qcow2 disk image '{disk_image}' for {disk_name} {e}")
else:
disk = disk_image
options.extend(await self._disk_interface_options(disk, disk_index, interface))
# config disk
disk_image = getattr(self, "config_disk_image")
if disk_image and self._create_config_disk:
disk_name = getattr(self, "config_disk_name")
disk = os.path.join(self.working_dir, disk_name)
if self.hdd_disk_interface == "none":
# use the HDA interface type if none has been configured for HDD
self.hdd_disk_interface = getattr(self, "hda_disk_interface", "none")
await self._import_config()
disk_exists = os.path.exists(disk)
if not disk_exists:
try:
shutil.copyfile(disk_image, disk)
disk_exists = True
except OSError as e:
2021-04-13 09:07:58 +00:00
log.warning(f"Could not create '{disk_name}' disk image: {e}")
if disk_exists:
options.extend(await self._disk_interface_options(disk, 3, self.hdd_disk_interface, "raw"))
2015-02-19 10:33:25 +00:00
return options
async def resize_disk(self, drive_name, extend):
if self.is_running():
2021-04-13 09:07:58 +00:00
raise QemuError(f"Cannot resize {drive_name} while the VM is running")
if self.linked_clone:
2021-04-13 09:07:58 +00:00
disk_image_path = os.path.join(self.working_dir, f"{drive_name}_disk.qcow2")
if not os.path.exists(disk_image_path):
2021-04-13 09:07:58 +00:00
disk_image = getattr(self, f"_{drive_name}_disk_image")
await self._create_linked_clone(drive_name, disk_image, disk_image_path)
else:
2021-04-13 09:07:58 +00:00
disk_image_path = getattr(self, f"{drive_name}_disk_image")
if not os.path.exists(disk_image_path):
2021-04-13 09:07:58 +00:00
raise QemuError(f"Disk path '{disk_image_path}' does not exist")
qemu_img_path = self._get_qemu_img()
await self.manager.resize_disk(qemu_img_path, disk_image_path, extend)
def _cdrom_option(self):
options = []
if self._cdrom_image:
if not os.path.isfile(self._cdrom_image) or not os.path.exists(self._cdrom_image):
if os.path.islink(self._cdrom_image):
2021-04-13 09:16:50 +00:00
raise QemuError(
f"cdrom image '{self._cdrom_image}' linked to '{os.path.realpath(self._cdrom_image)}' is not accessible"
)
else:
2021-04-13 09:07:58 +00:00
raise QemuError(f"cdrom image '{self._cdrom_image}' is not accessible")
if self._hdc_disk_image:
raise QemuError("You cannot use a disk image on hdc disk and a CDROM image at the same time")
options.extend(["-cdrom", self._cdrom_image.replace(",", ",,")])
return options
def _bios_option(self):
options = []
if self._bios_image:
if not os.path.isfile(self._bios_image) or not os.path.exists(self._bios_image):
if os.path.islink(self._bios_image):
2021-04-13 09:16:50 +00:00
raise QemuError(
f"bios image '{self._bios_image}' linked to '{os.path.realpath(self._bios_image)}' is not accessible"
)
else:
2021-04-13 09:07:58 +00:00
raise QemuError(f"bios image '{self._bios_image}' is not accessible")
options.extend(["-bios", self._bios_image.replace(",", ",,")])
return options
2015-02-19 10:33:25 +00:00
def _linux_boot_options(self):
options = []
if self._initrd:
if not os.path.isfile(self._initrd) or not os.path.exists(self._initrd):
if os.path.islink(self._initrd):
2021-04-13 09:16:50 +00:00
raise QemuError(
f"initrd file '{self._initrd}' linked to '{os.path.realpath(self._initrd)}' is not accessible"
)
2015-02-19 10:33:25 +00:00
else:
2021-04-13 09:07:58 +00:00
raise QemuError(f"initrd file '{self._initrd}' is not accessible")
options.extend(["-initrd", self._initrd.replace(",", ",,")])
2015-02-19 10:33:25 +00:00
if self._kernel_image:
if not os.path.isfile(self._kernel_image) or not os.path.exists(self._kernel_image):
if os.path.islink(self._kernel_image):
2021-04-13 09:16:50 +00:00
raise QemuError(
f"kernel image '{self._kernel_image}' linked to '{os.path.realpath(self._kernel_image)}' is not accessible"
)
2015-02-19 10:33:25 +00:00
else:
2021-04-13 09:07:58 +00:00
raise QemuError(f"kernel image '{self._kernel_image}' is not accessible")
options.extend(["-kernel", self._kernel_image.replace(",", ",,")])
2015-02-19 10:33:25 +00:00
if self._kernel_command_line:
options.extend(["-append", self._kernel_command_line])
return options
async def _network_options(self):
2015-02-19 10:33:25 +00:00
network_options = []
2021-04-13 09:16:50 +00:00
network_options.extend(
["-net", "none"]
) # we do not want any user networking back-end if no adapter is connected.
# Each 32 PCI device we need to add a PCI bridge with max 9 bridges
pci_devices = 4 + len(self._ethernet_adapters) # 4 PCI devices are use by default by qemu
pci_bridges = math.floor(pci_devices / 32)
pci_bridges_created = 0
if pci_bridges >= 1:
qemu_version = await self.manager.get_qemu_version(self.qemu_path)
if qemu_version and parse_version(qemu_version) < parse_version("2.4.0"):
2021-04-13 09:16:50 +00:00
raise QemuError(
"Qemu version 2.4 or later is required to run this VM with a large number of network adapters"
)
pci_device_id = 4 + pci_bridges # Bridge consume PCI ports
for adapter_number, adapter in enumerate(self._ethernet_adapters):
mac = int_to_macaddress(macaddress_to_int(self._mac_address) + adapter_number)
2017-07-11 11:42:47 +00:00
# use a local UDP tunnel to connect to uBridge instead
if adapter_number not in self._local_udp_tunnels:
self._local_udp_tunnels[adapter_number] = self._create_local_udp_tunnel()
nio = self._local_udp_tunnels[adapter_number][0]
custom_adapter = self._get_custom_adapter_settings(adapter_number)
adapter_type = custom_adapter.get("adapter_type", self._adapter_type)
custom_mac_address = custom_adapter.get("mac_address")
if custom_mac_address:
mac = int_to_macaddress(macaddress_to_int(custom_mac_address))
2021-10-19 05:02:27 +00:00
device_string = f"{adapter_type},mac={mac}"
bridge_id = math.floor(pci_device_id / 32)
if bridge_id > 0:
if pci_bridges_created < bridge_id:
network_options.extend(["-device", f"i82801b11-bridge,id=dmi_pci_bridge{bridge_id}"])
network_options.extend(
[
"-device",
"pci-bridge,id=pci-bridge{bridge_id},bus=dmi_pci_bridge{bridge_id},chassis_nr=0x1,addr=0x{bridge_id},shpc=off".format(
bridge_id=bridge_id
),
]
)
pci_bridges_created += 1
addr = pci_device_id % 32
device_string = f"{device_string},bus=pci-bridge{bridge_id},addr=0x{addr:02x}"
pci_device_id += 1
if nio:
network_options.extend(["-device", f"{device_string},netdev=gns3-{adapter_number}"])
if isinstance(nio, NIOUDP):
network_options.extend(
[
"-netdev",
"socket,id=gns3-{},udp={}:{},localaddr={}:{}".format(
adapter_number, nio.rhost, nio.rport, "127.0.0.1", nio.lport
),
]
)
elif isinstance(nio, NIOTAP):
network_options.extend(
["-netdev", f"tap,id=gns3-{adapter_number},ifname={nio.tap_device},script=no,downscript=no"]
)
else:
2021-10-19 05:02:27 +00:00
network_options.extend(["-device", device_string])
2015-02-19 10:33:25 +00:00
return network_options
2019-02-22 11:04:49 +00:00
async def _disable_graphics(self):
"""
Disable graphics depending of the QEMU version
"""
2015-04-08 17:17:34 +00:00
if any(opt in self._options for opt in ["-display", "-nographic", "-curses", "-sdl" "-spice", "-vnc"]):
return []
2019-02-22 11:04:49 +00:00
version = await self.manager.get_qemu_version(self.qemu_path)
if version and parse_version(version) >= parse_version("3.0"):
return ["-display", "none"]
else:
2017-11-18 09:22:29 +00:00
return ["-nographic"]
async def _run_with_hardware_acceleration(self, qemu_path, options):
"""
Check if we can run Qemu with hardware acceleration
:param qemu_path: Path to qemu
:param options: String of qemu user options
:returns: Boolean True if we need to enable hardware acceleration
"""
enable_hardware_accel = self.manager.config.settings.Qemu.enable_hardware_acceleration
require_hardware_accel = self.manager.config.settings.Qemu.require_hardware_acceleration
if enable_hardware_accel and "-machine accel=tcg" not in options:
# Turn OFF hardware acceleration for non x86 architectures
2022-01-19 11:58:36 +00:00
supported_binaries = ["qemu-system-x86_64", "qemu-system-i386", "qemu-kvm"]
if os.path.basename(qemu_path) not in supported_binaries:
if require_hardware_accel:
2021-04-13 09:16:50 +00:00
raise QemuError(
"Hardware acceleration can only be used with the following Qemu executables: {}".format(
", ".join(supported_binaries)
)
)
else:
return False
if sys.platform.startswith("linux") and not os.path.exists("/dev/kvm"):
if require_hardware_accel:
2021-04-13 09:16:50 +00:00
raise QemuError(
"KVM acceleration cannot be used (/dev/kvm doesn't exist). It is possible to turn off KVM support in the gns3_server.conf by adding enable_hardware_acceleration = false to the [Qemu] section."
)
else:
return False
elif sys.platform.startswith("darwin"):
process = await asyncio.create_subprocess_shell("kextstat | grep com.intel.kext.intelhaxm")
await process.wait()
if process.returncode != 0:
if require_hardware_accel:
2021-04-13 09:16:50 +00:00
raise QemuError(
"HAXM acceleration support is not installed on this host (com.intel.kext.intelhaxm extension not loaded)"
)
else:
return False
return True
return False
async def _clear_save_vm_stated(self, snapshot_name="GNS3_SAVED_STATE"):
drives = ["a", "b", "c", "d"]
qemu_img_path = self._get_qemu_img()
for disk_index, drive in enumerate(drives):
2021-04-13 09:07:58 +00:00
disk_image = getattr(self, f"_hd{drive}_disk_image")
if not disk_image:
continue
try:
if self.linked_clone:
2021-04-13 09:07:58 +00:00
disk = os.path.join(self.working_dir, f"hd{drive}_disk.qcow2")
else:
disk = disk_image
2018-04-06 06:19:54 +00:00
if not os.path.exists(disk):
continue
output = await subprocess_check_output(qemu_img_path, "info", "--output=json", disk)
if output:
try:
json_data = json.loads(output)
except ValueError as e:
2021-04-13 09:16:50 +00:00
raise QemuError(
f"Invalid JSON data returned by qemu-img while looking for the Qemu VM saved state snapshot: {e}"
)
if "snapshots" in json_data:
for snapshot in json_data["snapshots"]:
if snapshot["name"] == snapshot_name:
# delete the snapshot
command = [qemu_img_path, "snapshot", "-d", snapshot_name, disk]
retcode = await self._qemu_img_exec(command)
if retcode:
stdout = self.read_qemu_img_stdout()
2021-04-13 09:07:58 +00:00
log.warning(f"Could not delete saved VM state from disk {disk}: {stdout}")
else:
2021-04-13 09:07:58 +00:00
log.info(f"Deleted saved VM state from disk {disk}")
except subprocess.SubprocessError as e:
2021-04-13 09:07:58 +00:00
raise QemuError(f"Error while looking for the Qemu VM saved state snapshot: {e}")
async def _saved_state_option(self, snapshot_name="GNS3_SAVED_STATE"):
drives = ["a", "b", "c", "d"]
qemu_img_path = self._get_qemu_img()
for disk_index, drive in enumerate(drives):
2021-04-13 09:07:58 +00:00
disk_image = getattr(self, f"_hd{drive}_disk_image")
if not disk_image:
continue
try:
if self.linked_clone:
2021-04-13 09:07:58 +00:00
disk = os.path.join(self.working_dir, f"hd{drive}_disk.qcow2")
else:
disk = disk_image
2018-04-06 06:19:54 +00:00
if not os.path.exists(disk):
continue
output = await subprocess_check_output(qemu_img_path, "info", "--output=json", disk)
if output:
try:
json_data = json.loads(output)
except ValueError as e:
2021-04-13 09:16:50 +00:00
raise QemuError(
f"Invalid JSON data returned by qemu-img while looking for the Qemu VM saved state snapshot: {e}"
)
if "snapshots" in json_data:
for snapshot in json_data["snapshots"]:
if snapshot["name"] == snapshot_name:
2021-04-13 09:16:50 +00:00
log.info(
'QEMU VM "{name}" [{id}] VM saved state detected (snapshot name: {snapshot})'.format(
name=self._name, id=self.id, snapshot=snapshot_name
)
)
return ["-loadvm", snapshot_name.replace(",", ",,")]
except subprocess.SubprocessError as e:
2021-04-13 09:07:58 +00:00
raise QemuError(f"Error while looking for the Qemu VM saved state snapshot: {e}")
return []
async def _build_command(self):
2015-02-19 10:33:25 +00:00
"""
Command to start the QEMU process.
(to be passed to subprocess.Popen())
"""
vm_name = self._name.replace(",", ",,")
project_path = self.project.path.replace(",", ",,")
2016-10-03 13:54:20 +00:00
additional_options = self._options.strip()
additional_options = additional_options.replace("%vm-name%", '"' + vm_name.replace('"', '\\"') + '"')
additional_options = additional_options.replace("%vm-id%", self._id)
additional_options = additional_options.replace("%project-id%", self.project.id)
additional_options = additional_options.replace("%project-path%", '"' + project_path.replace('"', '\\"') + '"')
additional_options = additional_options.replace("%guest-cid%", str(self._guest_cid))
if self._console_type != "none" and self._console:
additional_options = additional_options.replace("%console-port%", str(self._console))
command = [self.qemu_path]
command.extend(["-name", vm_name])
2021-04-13 09:07:58 +00:00
command.extend(["-m", f"{self._ram}M"])
# set the maximum number of the hotpluggable CPUs to match the number of CPUs to avoid issues.
maxcpus = self._maxcpus
if self._cpus > maxcpus:
maxcpus = self._cpus
2021-04-13 09:07:58 +00:00
command.extend(["-smp", f"cpus={self._cpus},maxcpus={maxcpus},sockets=1"])
2021-04-13 09:16:50 +00:00
if await self._run_with_hardware_acceleration(self.qemu_path, self._options):
if sys.platform.startswith("linux"):
command.extend(["-enable-kvm"])
version = await self.manager.get_qemu_version(self.qemu_path)
# Issue on some combo Intel CPU + KVM + Qemu 2.4.0
# https://github.com/GNS3/gns3-server/issues/685
if version and parse_version(version) >= parse_version("2.4.0") and self.platform == "x86_64":
command.extend(["-machine", "smm=off"])
2022-01-19 11:58:36 +00:00
elif sys.platform.startswith("darwin"):
command.extend(["-enable-hax"])
2021-04-13 09:07:58 +00:00
command.extend(["-boot", f"order={self._boot_priority}"])
command.extend(self._bios_option())
command.extend(self._cdrom_option())
2021-04-13 09:07:58 +00:00
command.extend(await self._disk_options())
2015-02-19 10:33:25 +00:00
command.extend(self._linux_boot_options())
2016-10-03 13:54:20 +00:00
if "-uuid" not in additional_options:
command.extend(["-uuid", self._id])
command.extend(self._console_options())
command.extend(self._aux_options())
2015-02-19 10:33:25 +00:00
command.extend(self._monitor_options())
2021-04-13 09:07:58 +00:00
command.extend(await self._network_options())
if self.on_close != "save_vm_state":
await self._clear_save_vm_stated()
else:
2021-04-13 09:07:58 +00:00
command.extend(await self._saved_state_option())
if self._console_type == "telnet":
2021-04-13 09:07:58 +00:00
command.extend(await self._disable_graphics())
2015-02-19 10:33:25 +00:00
if additional_options:
try:
command.extend(shlex.split(additional_options))
except ValueError as e:
2021-04-13 09:07:58 +00:00
raise QemuError(f"Invalid additional options: {additional_options} error {e}")
2015-02-19 10:33:25 +00:00
return command
2021-04-17 14:04:28 +00:00
def asdict(self):
2021-04-13 09:16:50 +00:00
answer = {"project_id": self.project.id, "node_id": self.id, "node_directory": self.working_path}
# Qemu has a long list of options. The JSON schema is the single source of information
2020-10-31 05:32:21 +00:00
for field in Qemu.schema()["properties"]:
2015-02-19 19:22:30 +00:00
if field not in answer:
try:
answer[field] = getattr(self, field)
except AttributeError:
pass
for drive in ["a", "b", "c", "d"]:
disk_image = getattr(self, f"_hd{drive}_disk_image")
if not disk_image:
continue
answer[f"hd{drive}_disk_image"] = self.manager.get_relative_image_path(disk_image, self.working_dir)
answer[f"hd{drive}_disk_image_md5sum"] = md5sum(disk_image, self.working_dir)
local_disk = os.path.join(self.working_dir, f"hd{drive}_disk.qcow2")
if os.path.exists(local_disk):
try:
qcow2 = Qcow2(local_disk)
if qcow2.backing_file:
answer[f"hd{drive}_disk_image_backed"] = os.path.basename(local_disk)
except (Qcow2Error, OSError) as e:
log.error(f"Could not read qcow2 disk image '{local_disk}': {e}")
continue
answer["cdrom_image"] = self.manager.get_relative_image_path(self._cdrom_image, self.working_dir)
answer["cdrom_image_md5sum"] = md5sum(self._cdrom_image, self.working_dir)
answer["bios_image"] = self.manager.get_relative_image_path(self._bios_image, self.working_dir)
answer["bios_image_md5sum"] = md5sum(self._bios_image, self.working_dir)
answer["initrd"] = self.manager.get_relative_image_path(self._initrd, self.working_dir)
answer["initrd_md5sum"] = md5sum(self._initrd, self.working_dir)
answer["kernel_image"] = self.manager.get_relative_image_path(self._kernel_image, self.working_dir)
answer["kernel_image_md5sum"] = md5sum(self._kernel_image, self.working_dir)
2015-02-19 19:22:30 +00:00
return answer