1736 lines
56 KiB
Python
1736 lines
56 KiB
Python
#!/usr/bin/python2 -O
|
|
# vim: fileencoding=utf-8
|
|
|
|
#
|
|
# The Qubes OS Project, https://www.qubes-os.org/
|
|
#
|
|
# Copyright (C) 2010-2015 Joanna Rutkowska <joanna@invisiblethingslab.com>
|
|
# Copyright (C) 2013-2015 Marek Marczykowski-Górecki
|
|
# <marmarek@invisiblethingslab.com>
|
|
# Copyright (C) 2014-2015 Wojtek Porczyk <woju@invisiblethingslab.com>
|
|
#
|
|
# 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, write to the Free Software Foundation, Inc.,
|
|
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
#
|
|
|
|
import datetime
|
|
import lxml.etree
|
|
import os
|
|
import os.path
|
|
import re
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
import time
|
|
import uuid
|
|
import xml.parsers.expat
|
|
import libvirt
|
|
import warnings
|
|
|
|
import qubes
|
|
import qubes.config
|
|
#import qubes.qdb
|
|
#import qubes.qmemman
|
|
#import qubes.qmemman_algo
|
|
import qubes.storage
|
|
import qubes.utils
|
|
import qubes.vm
|
|
|
|
qmemman_present = False
|
|
try:
|
|
import qubes.qmemman_client
|
|
qmemman_present = True
|
|
except ImportError:
|
|
pass
|
|
|
|
|
|
def _setter_qid(self, prop, value):
|
|
if not 0 <= value <= qubes.config.max_qid:
|
|
raise ValueError(
|
|
'{} value must be between 0 and qubes.config.max_qid'.format(
|
|
prop.__name__))
|
|
return value
|
|
|
|
|
|
def _setter_name(self, prop, value):
|
|
if not isinstance(value, basestring):
|
|
raise TypeError('{} value must be string, {!r} found'.format(
|
|
prop.__name__, type(value).__name__))
|
|
if len(value) > 31:
|
|
raise ValueError('{} value must be shorter than 32 characters'.format(
|
|
prop.__name__))
|
|
if re.match(r"^[a-zA-Z][a-zA-Z0-9_-]*$", value) is None:
|
|
raise ValueError('{} value contains illegal characters'.format(
|
|
prop.__name__))
|
|
if self.is_running():
|
|
raise qubes.QubesException('Cannot change name of running VM')
|
|
|
|
try:
|
|
if self.installed_by_rpm:
|
|
raise qubes.QubesException('Cannot rename VM installed by RPM -- '
|
|
'first clone VM and then use yum to remove package.')
|
|
except AttributeError:
|
|
pass
|
|
|
|
return value
|
|
|
|
|
|
def _setter_kernel(self, prop, value):
|
|
if not os.path.exists(os.path.join(system_path[
|
|
'qubes_kernels_base_dir'], value)):
|
|
raise qubes.QubesException('Kernel {!r} not installed'.format(value))
|
|
for f in ('vmlinuz', 'modules.img'):
|
|
if not os.path.exists(os.path.join(
|
|
system_path['qubes_kernels_base_dir'], value, f)):
|
|
raise qubes.QubesException(
|
|
'Kernel {!r} not properly installed: missing {!r} file'.format(
|
|
value, f))
|
|
return value
|
|
|
|
|
|
def _default_conf_file(self, name=None):
|
|
return (name or self.name) + '.conf'
|
|
|
|
|
|
class QubesVM(qubes.vm.BaseVM):
|
|
'''Base functionality of Qubes VM shared between all VMs.'''
|
|
|
|
#
|
|
# properties loaded from XML
|
|
#
|
|
|
|
label = qubes.property('label',
|
|
setter=(lambda self, prop, value: self.app.labels[
|
|
int(value.rsplit('-', 1)[1])]),
|
|
doc='Colourful label assigned to VM. This is where you set the colour '
|
|
'of the padlock.')
|
|
|
|
# XXX swallowed uses_default_netvm
|
|
netvm = qubes.VMProperty('netvm', load_stage=4, allow_none=True,
|
|
default=(lambda self: self.app.default_fw_netvm if self.provides_network
|
|
else self.app.default_netvm),
|
|
doc='''VM that provides network connection to this domain. When
|
|
`None`, machine is disconnected. When absent, domain uses default
|
|
NetVM.''')
|
|
|
|
provides_network = qubes.property('provides_network',
|
|
type=bool, setter=qubes.property.bool,
|
|
doc='`True` if it is NetVM or ProxyVM, false otherwise.')
|
|
|
|
qid = qubes.property('qid', type=int,
|
|
setter=_setter_qid,
|
|
doc='''Internal, persistent identificator of particular domain. Note
|
|
this is different from Xen domid.''')
|
|
|
|
name = qubes.property('name', type=str,
|
|
doc='User-specified name of the domain.')
|
|
|
|
uuid = qubes.property('uuid', type=uuid.UUID, default=None,
|
|
doc='UUID from libvirt.')
|
|
|
|
# TODO meaningful default
|
|
# TODO setter to ensure absolute/relative path?
|
|
dir_path = qubes.property('dir_path', type=str, default=None,
|
|
doc='FIXME')
|
|
|
|
conf_file = qubes.property('conf_file', type=str,
|
|
default=_default_conf_file,
|
|
saver=(lambda self, prop, value: self.relative_path(value)),
|
|
doc='XXX libvirt config file?')
|
|
|
|
# XXX this should be part of qubes.xml
|
|
firewall_conf = qubes.property('firewall_conf', type=str,
|
|
default='firewall.xml')
|
|
|
|
installed_by_rpm = qubes.property('installed_by_rpm',
|
|
type=bool, setter=qubes.property.bool,
|
|
default=False,
|
|
doc='''If this domain's image was installed from package tracked by
|
|
package manager.''')
|
|
|
|
memory = qubes.property('memory', type=int,
|
|
default=qubes.config.defaults['memory'],
|
|
doc='Memory currently available for this VM.')
|
|
|
|
maxmem = qubes.property('maxmem', type=int, default=None,
|
|
doc='''Maximum amount of memory available for this VM (for the purpose
|
|
of the memory balancer).''')
|
|
|
|
internal = qubes.property('internal', default=False,
|
|
type=bool, setter=qubes.property.bool,
|
|
doc='''Internal VM (not shown in qubes-manager, don't create appmenus
|
|
entries.''')
|
|
|
|
# XXX what is that
|
|
vcpus = qubes.property('vcpus', default=None,
|
|
doc='FIXME')
|
|
|
|
# XXX swallowed uses_default_kernel
|
|
# XXX not applicable to HVM?
|
|
kernel = qubes.property('kernel', type=str,
|
|
setter=_setter_kernel,
|
|
default=(lambda self: self.app.default_kernel),
|
|
doc='Kernel used by this domain.')
|
|
|
|
# XXX swallowed uses_default_kernelopts
|
|
# XXX not applicable to HVM?
|
|
kernelopts = qubes.property('kernelopts', type=str, load_stage=4,
|
|
default=(lambda self: defaults['kernelopts_pcidevs'] \
|
|
if len(self.devices['pci']) > 0 \
|
|
else qubes.config.defaults['kernelopts']),
|
|
doc='Kernel command line passed to domain.')
|
|
|
|
mac = qubes.property('mac', type=str,
|
|
default=(lambda self: '00:16:3E:5E:6C:{:02X}'.format(self.qid)),
|
|
doc='MAC address of the NIC emulated inside VM')
|
|
|
|
debug = qubes.property('debug', type=bool, default=False,
|
|
setter=qubes.property.bool,
|
|
doc='Turns on debugging features.')
|
|
|
|
# XXX what this exactly does?
|
|
# XXX shouldn't this go to standalone VM and TemplateVM, and leave here
|
|
# only plain property?
|
|
default_user = qubes.property('default_user', type=str,
|
|
default=(lambda self: self.template.default_user),
|
|
doc='FIXME')
|
|
|
|
# @property
|
|
# def default_user(self):
|
|
# if self.template is not None:
|
|
# return self.template.default_user
|
|
# else:
|
|
# return self._default_user
|
|
|
|
qrexec_timeout = qubes.property('qrexec_timeout', type=int, default=60,
|
|
doc='''Time in seconds after which qrexec connection attempt is deemed
|
|
failed. Operating system inside VM should be able to boot in this
|
|
time.''')
|
|
|
|
autostart = qubes.property('autostart', default=False,
|
|
type=bool, setter=qubes.property.bool,
|
|
doc='''Setting this to `True` means that VM should be autostarted on
|
|
dom0 boot.''')
|
|
|
|
# XXX I don't understand backups
|
|
include_in_backups = qubes.property('include_in_backups', default=True,
|
|
type=bool, setter=qubes.property.bool,
|
|
doc='If this domain is to be included in default backup.')
|
|
|
|
backup_content = qubes.property('backup_content', default=False,
|
|
type=bool, setter=qubes.property.bool,
|
|
doc='FIXME')
|
|
|
|
backup_size = qubes.property('backup_size', type=int, default=0,
|
|
doc='FIXME')
|
|
|
|
backup_path = qubes.property('backup_path', type=str, default='',
|
|
doc='FIXME')
|
|
|
|
# format got changed from %s to str(datetime.datetime)
|
|
backup_timestamp = qubes.property('backup_timestamp', default=None,
|
|
setter=(lambda self, prop, value:
|
|
datetime.datetime.fromtimestamp(value)),
|
|
saver=(lambda self, prop, value: value.strftime('%s')),
|
|
doc='FIXME')
|
|
|
|
|
|
#
|
|
# static, class-wide properties
|
|
#
|
|
|
|
# config file should go away to storage/backend class
|
|
#: template for libvirt config file (XML)
|
|
config_file_template = qubes.config.system_path["config_template_pv"]
|
|
|
|
#
|
|
# properties not loaded from XML, calculated at run-time
|
|
#
|
|
|
|
# VMM-related
|
|
|
|
@property
|
|
def xid(self):
|
|
'''Xen ID.
|
|
|
|
Or not Xen, but ID.
|
|
'''
|
|
|
|
if self.libvirt_domain is None:
|
|
return -1
|
|
return self.libvirt_domain.ID()
|
|
|
|
|
|
@property
|
|
def libvirt_domain(self):
|
|
'''Libvirt domain object from libvirt.
|
|
|
|
May be :py:obj:`None`, if libvirt knows nothing about this domain.
|
|
'''
|
|
|
|
if self._libvirt_domain is not None:
|
|
return self._libvirt_domain
|
|
|
|
# XXX _update_libvirt_domain?
|
|
try:
|
|
if self.uuid is not None:
|
|
self._libvirt_domain = vmm.libvirt_conn.lookupByUUID(
|
|
self.uuid.bytes)
|
|
else:
|
|
self._libvirt_domain = vmm.libvirt_conn.lookupByName(self.name)
|
|
self.uuid = uuid.UUID(bytes=self._libvirt_domain.UUID())
|
|
except libvirt.libvirtError:
|
|
if vmm.libvirt_conn.virConnGetLastError()[0] == \
|
|
libvirt.VIR_ERR_NO_DOMAIN:
|
|
self._update_libvirt_domain()
|
|
else:
|
|
raise
|
|
return self._libvirt_domain
|
|
|
|
|
|
@property
|
|
def qdb(self):
|
|
'''QubesDB handle for this domain.'''
|
|
if self._qdb_connection is None:
|
|
if self.is_running():
|
|
self._qdb_connection = qubes.qdb.QubesDB(self.name)
|
|
return self._qdb_connection
|
|
|
|
|
|
# XXX this should go to to AppVM?
|
|
@property
|
|
def private_img(self):
|
|
'''Location of private image of the VM (that contains :file:`/rw` \
|
|
and :file:`/home`).'''
|
|
return self.storage.private_img
|
|
|
|
|
|
# XXX this should go to to AppVM? or TemplateVM?
|
|
@property
|
|
def root_img(self):
|
|
'''Location of root image.'''
|
|
return self.storage.root_img
|
|
|
|
|
|
# XXX and this should go to exactly where? DispVM has it.
|
|
@property
|
|
def volatile_img(self):
|
|
'''Volatile image that overlays :py:attr:`root_img`.'''
|
|
return self.storage.volatile_img
|
|
|
|
|
|
# XXX shouldn't this go elsewhere?
|
|
@property
|
|
def updateable(self):
|
|
'''True if this machine may be updated on its own.'''
|
|
return hasattr(self, 'template')
|
|
|
|
|
|
@property
|
|
def uses_custom_config(self):
|
|
'''True if this machine has config in non-standard place.'''
|
|
return not self.property_is_default(self, 'conf_file')
|
|
# return self.conf_file != self.storage.abspath(self.name + '.conf')
|
|
|
|
@property
|
|
def icon_path(self):
|
|
return self.dir_path and os.path.join(self.dir_path, "icon.png")
|
|
|
|
|
|
# XXX I don't know what to do with these; probably should be isinstance(...)
|
|
# def is_template(self):
|
|
# return False
|
|
#
|
|
# def is_appvm(self):
|
|
# return False
|
|
#
|
|
# def is_proxyvm(self):
|
|
# return False
|
|
#
|
|
# def is_disposablevm(self):
|
|
# return False
|
|
|
|
|
|
# network-related
|
|
|
|
@property
|
|
def ip(self):
|
|
'''IP address of this domain.'''
|
|
if self.netvm is not None:
|
|
return self.netvm.get_ip_for_vm(self.qid)
|
|
else:
|
|
return None
|
|
|
|
@property
|
|
def netmask(self):
|
|
'''Netmask for this domain's IP address.'''
|
|
if self.netvm is not None:
|
|
return self.netvm.netmask
|
|
else:
|
|
return None
|
|
|
|
@property
|
|
def gateway(self):
|
|
'''Gateway for other domains that use this domain as netvm.'''
|
|
# This is gateway IP for _other_ VMs, so make sense only in NetVMs
|
|
return None
|
|
|
|
@property
|
|
def secondary_dns(self):
|
|
'''Secondary DNS server set up for this domain.'''
|
|
if self.netvm is not None:
|
|
return self.netvm.secondary_dns
|
|
else:
|
|
return None
|
|
|
|
@property
|
|
def vif(self):
|
|
'''Name of the network interface backend in netvm that is connected to
|
|
NIC inside this domain.'''
|
|
if self.xid < 0:
|
|
return None
|
|
if self.netvm is None:
|
|
return None
|
|
return "vif{0}.+".format(self.xid)
|
|
|
|
#
|
|
# constructor
|
|
#
|
|
|
|
def __init__(self, app, xml, **kwargs):
|
|
super(QubesVM, self).__init__(app, xml, **kwargs)
|
|
|
|
#Init private attrs
|
|
|
|
self._libvirt_domain = None
|
|
self._qdb_connection = None
|
|
|
|
assert self.qid < qubes.config.max_qid, "VM id out of bounds!"
|
|
assert self.name is not None
|
|
|
|
# Not in generic way to not create QubesHost() to frequently
|
|
# XXX this doesn't apply, host is instantiated once
|
|
if self.maxmem is None and not self.app.vmm.offline_mode:
|
|
total_mem_mb = self.app.host.memory_total/1024
|
|
self.maxmem = total_mem_mb/2
|
|
|
|
# Linux specific cap: max memory can't scale beyond 10.79*init_mem
|
|
# see https://groups.google.com/forum/#!topic/qubes-devel/VRqkFj1IOtA
|
|
if self.maxmem > self.memory * 10:
|
|
self.maxmem = self.memory * 10
|
|
|
|
# By default allow use all VCPUs
|
|
if not hasattr(self, 'vcpus') and not self.app.vmm.offline_mode:
|
|
self.vcpus = self.app.host.no_cpus
|
|
|
|
# Always set if meminfo-writer should be active or not
|
|
if 'meminfo-writer' not in self.services:
|
|
self.services['meminfo-writer'] = not len(self.devices['pci']) > 0
|
|
|
|
# Additionally force meminfo-writer disabled when VM have PCI devices
|
|
if len(self.devices['pci']) > 0:
|
|
self.services['meminfo-writer'] = False
|
|
|
|
# Initialize VM image storage class
|
|
self.storage = qubes.storage.get_storage(self)
|
|
|
|
if hasattr(self, 'kernels_dir'):
|
|
self.storage.modules_img = os.path.join(self.kernels_dir,
|
|
"modules.img")
|
|
self.storage.modules_img_rw = self.kernel is None
|
|
|
|
# fire hooks
|
|
self.fire_event('domain-init')
|
|
|
|
|
|
#
|
|
# event handlers
|
|
#
|
|
|
|
@qubes.events.handler('property-set:label')
|
|
def on_property_set_label(self, event, name, new_label, old_label=None):
|
|
if self.icon_path:
|
|
try:
|
|
os.remove(self.icon_path)
|
|
except:
|
|
pass
|
|
if hasattr(os, "symlink"):
|
|
os.symlink(new_label.icon_path, self.icon_path)
|
|
# FIXME: some os-independent wrapper?
|
|
subprocess.call(['sudo', 'xdg-icon-resource', 'forceupdate'])
|
|
else:
|
|
shutil.copy(new_label.icon_path, self.icon_path)
|
|
|
|
|
|
@qubes.events.handler('property-del:netvm')
|
|
def on_property_del_netvm(self, event, name, old_netvm):
|
|
# we are changing to default netvm
|
|
new_netvm = self.netvm
|
|
if new_netvm == old_netvm:
|
|
return
|
|
self.fire_event('property-set:netvm', 'netvm', new_netvm, old_netvm)
|
|
|
|
|
|
@qubes.events.handler('property-set:netvm')
|
|
def on_property_set_netvm(self, event, name, new_netvm, old_netvm=None):
|
|
if self.is_running() and new_netvm is not None \
|
|
and not new_netvm.is_running():
|
|
raise QubesException("Cannot dynamically attach to stopped NetVM")
|
|
|
|
if self.netvm is not None:
|
|
del self.netvm.connected_vms[self]
|
|
if self.is_running():
|
|
self.detach_network()
|
|
|
|
# TODO change to domain-removed event handler in netvm
|
|
# if hasattr(self.netvm, 'post_vm_net_detach'):
|
|
# self.netvm.post_vm_net_detach(self)
|
|
|
|
if new_netvm is None:
|
|
if not self._do_not_reset_firewall:
|
|
# Set also firewall to block all traffic as discussed in #370
|
|
if os.path.exists(self.firewall_conf):
|
|
shutil.copy(self.firewall_conf,
|
|
os.path.join(system_path["qubes_base_dir"],
|
|
"backup",
|
|
"%s-firewall-%s.xml" % (self.name,
|
|
time.strftime('%Y-%m-%d-%H:%M:%S'))))
|
|
self.write_firewall_conf({'allow': False, 'allowDns': False,
|
|
'allowIcmp': False, 'allowYumProxy': False, 'rules': []})
|
|
else:
|
|
new_netvm.connected_vms.add(self)
|
|
|
|
if new_netvm is None:
|
|
return
|
|
|
|
if self.is_running():
|
|
# refresh IP, DNS etc
|
|
self.create_qdb_entries()
|
|
self.attach_network()
|
|
|
|
# TODO domain-added event handler in netvm
|
|
# if hasattr(self.netvm, 'post_vm_net_attach'):
|
|
# self.netvm.post_vm_net_attach(self)
|
|
|
|
|
|
@qubes.events.handler('property-pre-set:name')
|
|
def on_property_pre_set_name(self, event, name, newvalue, oldvalue=None):
|
|
# TODO not self.is_stopped() would be more appropriate
|
|
if self.is_running():
|
|
raise QubesException('Cannot change name of running domain')
|
|
|
|
|
|
@qubes.events.handler('property-pre-set:dir_path')
|
|
def on_property_pre_set_name(self, event, name, newvalue, oldvalue=None):
|
|
# TODO not self.is_stopped() would be more appropriate
|
|
if self.is_running():
|
|
raise QubesException('Cannot change dir_path of running domain')
|
|
|
|
|
|
@qubes.events.handler('property-set:dir_path')
|
|
def on_property_set_dir_path(self, event, name, newvalue, oldvalue=None):
|
|
self.storage.rename(newvalue, oldvalue)
|
|
|
|
|
|
@qubes.events.handler('property-set:name')
|
|
def on_property_set_name(self, event, name, new_name, old_name=None):
|
|
if self._libvirt_domain is not None:
|
|
self.libvirt_domain.undefine()
|
|
self._libvirt_domain = None
|
|
if self._qdb_connection is not None:
|
|
self._qdb_connection.close()
|
|
self._qdb_connection = None
|
|
|
|
# move: dir_path, conf_file
|
|
self.dir_path = self.dir_path.replace(
|
|
'/{}/', '/{}/'.format(old_name, new_name))
|
|
|
|
if self.property_is_default(self, 'conf_file'):
|
|
new_conf = os.path.join(
|
|
self.dir_path, _default_conf_file(self, old_name))
|
|
old_conf = os.path.join(
|
|
self.dir_path, _default_conf_file(self, old_name))
|
|
self.storage.rename(old_conf, new_conf)
|
|
|
|
self.fire_event('property-set:conf_file', 'conf_file',
|
|
new_conf, old_conf)
|
|
|
|
if hasattr(self, 'kernels_dir') and self.kernels_dir is not None:
|
|
self.kernels_dir = self.kernels_dir.replace(
|
|
old_dirpath, new_dirpath)
|
|
|
|
self._update_libvirt_domain()
|
|
|
|
|
|
@qubes.events.handler('property-pre-set:autostart')
|
|
def on_property_pre_set_autostart(self, event, prop, name, value,
|
|
oldvalue=None):
|
|
if subprocess.call(['sudo', 'systemctl',
|
|
('enable' if value else 'disable'),
|
|
'qubes-vm@{}.service'.format(self.name)]):
|
|
raise QubesException("Failed to set autostart for VM via systemctl")
|
|
|
|
|
|
@qubes.events.handler('device-pre-attached:pci')
|
|
def on_device_pre_attached_pci(self, event, pci):
|
|
if not os.path.exists('/sys/bus/pci/devices/0000:%s' % pci):
|
|
raise QubesException("Invalid PCI device: %s" % pci)
|
|
if not self.is_running():
|
|
return
|
|
|
|
try:
|
|
# TODO: libvirt-ise
|
|
subprocess.check_call(
|
|
['sudo', system_path["qubes_pciback_cmd"], pci])
|
|
subprocess.check_call(
|
|
['sudo', 'xl', 'pci-attach', str(self.xid), pci])
|
|
except Exception as e:
|
|
print >>sys.stderr, "Failed to attach PCI device on the fly " \
|
|
"(%s), changes will be seen after VM restart" % str(e)
|
|
|
|
|
|
@qubes.events.handler('device-pre-detached:pci')
|
|
def on_device_pre_detached_pci(self, event, pci):
|
|
if not self.is_running():
|
|
return
|
|
|
|
# TODO: libvirt-ise
|
|
p = subprocess.Popen(['xl', 'pci-list', str(self.xid)],
|
|
stdout=subprocess.PIPE)
|
|
result = p.communicate()
|
|
m = re.search(r"^(\d+.\d+)\s+0000:%s$" % pci, result[0],
|
|
flags=re.MULTILINE)
|
|
if not m:
|
|
print >>sys.stderr, "Device %s already detached" % pci
|
|
return
|
|
vmdev = m.group(1)
|
|
try:
|
|
self.run_service("qubes.DetachPciDevice",
|
|
user="root", input="00:%s" % vmdev)
|
|
subprocess.check_call(
|
|
['sudo', 'xl', 'pci-detach', str(self.xid), pci])
|
|
except Exception as e:
|
|
print >>sys.stderr, "Failed to detach PCI device on the fly " \
|
|
"(%s), changes will be seen after VM restart" % str(e)
|
|
|
|
|
|
#
|
|
# methods for changing domain state
|
|
#
|
|
|
|
def start(self, preparing_dvm=False, start_guid=True,
|
|
notify_function=None, mem_required=None):
|
|
'''Start domain
|
|
|
|
:param bool preparing_dvm: FIXME
|
|
:param bool start_guid: FIXME
|
|
:param collections.Callable notify_function: FIXME
|
|
:param int mem_required: FIXME
|
|
'''
|
|
|
|
# Intentionally not used is_running(): eliminate also "Paused",
|
|
# "Crashed", "Halting"
|
|
if self.get_power_state() != "Halted":
|
|
raise QubesException("VM is already running!")
|
|
|
|
self.log.info('Starting {}'.format(self.name))
|
|
|
|
self.verify_files()
|
|
|
|
if self.netvm is not None:
|
|
if self.netvm.qid != 0:
|
|
if not self.netvm.is_running():
|
|
self.netvm.start(start_guid=start_guid,
|
|
notify_function=notify_function)
|
|
|
|
self.storage.prepare_for_vm_startup()
|
|
self._update_libvirt_domain()
|
|
|
|
if mem_required is None:
|
|
mem_required = int(self.memory) * 1024 * 1024
|
|
if qmemman_present:
|
|
qmemman_client = qubes.qmemman_client.QMemmanClient()
|
|
try:
|
|
got_memory = qmemman_client.request_memory(mem_required)
|
|
except IOError as e:
|
|
raise IOError('Failed to connect to qmemman: {!s}'.format(e))
|
|
if not got_memory:
|
|
qmemman_client.close()
|
|
raise MemoryError(
|
|
'Insufficient memory to start VM {!r}'.format(self.name))
|
|
|
|
# Bind pci devices to pciback driver
|
|
for pci in self.devices['pci']:
|
|
nd = vmm.libvirt_conn.nodeDeviceLookupByName(
|
|
'pci_0000_' + pci.replace(':', '_').replace('.', '_'))
|
|
try:
|
|
nd.dettach()
|
|
except libvirt.libvirtError:
|
|
if vmm.libvirt_conn.virConnGetLastError()[0] == \
|
|
libvirt.VIR_ERR_INTERNAL_ERROR:
|
|
# already detached
|
|
pass
|
|
else:
|
|
raise
|
|
|
|
self.libvirt_domain.createWithFlags(libvirt.VIR_DOMAIN_START_PAUSED)
|
|
|
|
if preparing_dvm:
|
|
self.services['qubes-dvm'] = True
|
|
|
|
self.log.info('Setting Qubes DB info for the VM')
|
|
self.start_qubesdb()
|
|
self.create_qdb_entries()
|
|
|
|
self.log.info('Updating firewall rules')
|
|
|
|
for vm in self.app.domains:
|
|
if vm.is_proxyvm() and vm.is_running():
|
|
vm.write_iptables_xenstore_entry()
|
|
|
|
self.fire_event('domain-started',
|
|
preparing_dvm=preparing_dvm, start_guid=start_guid)
|
|
|
|
|
|
self.log.warning('Activating the {} VM'.format(self.name))
|
|
self.libvirt_domain.resume()
|
|
|
|
# close() is not really needed, because the descriptor is close-on-exec
|
|
# anyway, the reason to postpone close() is that possibly xl is not done
|
|
# constructing the domain after its main process exits
|
|
# so we close() when we know the domain is up
|
|
# the successful unpause is some indicator of it
|
|
if qmemman_present:
|
|
qmemman_client.close()
|
|
|
|
if self._start_guid_first and start_guid and not preparing_dvm \
|
|
and os.path.exists('/var/run/shm.id'):
|
|
self.start_guid(notify_function=notify_function)
|
|
|
|
if not preparing_dvm:
|
|
self.start_qrexec_daemon(notify_function=notify_function)
|
|
|
|
if start_guid and not preparing_dvm \
|
|
and os.path.exists('/var/run/shm.id'):
|
|
self.start_guid(notify_function=notify_function)
|
|
|
|
|
|
def shutdown(self):
|
|
'''Shutdown domain.
|
|
|
|
:raises QubesException: when domain is already shut down.
|
|
'''
|
|
|
|
if not self.is_running():
|
|
raise QubesException("VM already stopped!")
|
|
|
|
self.libvirt_domain.shutdown()
|
|
|
|
|
|
def force_shutdown(self):
|
|
'''Forcefuly shutdown (destroy) domain.
|
|
|
|
:raises QubesException: when domain is already shut down.
|
|
'''
|
|
|
|
if not self.is_running() and not self.is_paused():
|
|
raise QubesException("VM already stopped!")
|
|
|
|
self.libvirt_domain.destroy()
|
|
|
|
|
|
def suspend(self):
|
|
'''Suspend (pause) domain.
|
|
|
|
:raises QubesException: when domain is already shut down.
|
|
:raises NotImplemetedError: when domain has PCI devices attached.
|
|
'''
|
|
|
|
if not self.is_running() and not self.is_paused():
|
|
raise QubesException("VM already stopped!")
|
|
|
|
if len(self.devices['pci']) > 0:
|
|
raise NotImplementedError()
|
|
else:
|
|
self.libvirt_domain.suspend()
|
|
|
|
|
|
def pause(self):
|
|
'''Pause (suspend) domain. This currently delegates to \
|
|
:py:meth:`suspend`.'''
|
|
|
|
if not self.is_running():
|
|
raise QubesException("VM not running!")
|
|
|
|
self.suspend()
|
|
|
|
|
|
def resume(self):
|
|
'''Resume suspended domain.
|
|
|
|
:raises NotImplemetedError: when machine is alread suspended.
|
|
'''
|
|
|
|
if self.get_power_state() == "Suspended":
|
|
raise NotImplementedError()
|
|
else:
|
|
self.unpause()
|
|
|
|
def unpause(self):
|
|
'''Resume (unpause) a domain'''
|
|
if not self.is_paused():
|
|
raise QubesException("VM not paused!")
|
|
|
|
self.libvirt_domain.resume()
|
|
|
|
|
|
def run(self, command, user=None, autostart=False, notify_function=None,
|
|
passio=False, passio_popen=False, passio_stderr=False,
|
|
ignore_stderr=False, localcmd=None, wait=False, gui=True,
|
|
filter_esc=False):
|
|
'''Run specified command inside domain
|
|
|
|
:param str command: the command to be run
|
|
:param str user: user to run the command as
|
|
:param bool autostart: if :py:obj:`True`, machine will be started if \
|
|
it is not running
|
|
:param collections.Callable notify_function: FIXME, may go away
|
|
:param bool passio: FIXME
|
|
:param bool passio_popen: if :py:obj:`True`, \
|
|
:py:class:`subprocess.Popen` object has connected ``stdin`` and \
|
|
``stdout``
|
|
:param bool passio_stderr: if :py:obj:`True`, \
|
|
:py:class:`subprocess.Popen` has additionaly ``stderr`` connected
|
|
:param bool ignore_stderr: if :py:obj:`True`, ``stderr`` is connected \
|
|
to :file:`/dev/null`
|
|
:param str localcmd: local command to communicate with remote command
|
|
:param bool wait: if :py:obj:`True`, wait for command completion
|
|
:param bool gui: when autostarting, also start gui daemon
|
|
:param bool filter_esc: filter escape sequences to protect terminal \
|
|
emulator
|
|
'''
|
|
|
|
if user is None:
|
|
user = self.default_user
|
|
null = None
|
|
if not self.is_running() and not self.is_paused():
|
|
if not autostart:
|
|
raise QubesException("VM not running")
|
|
|
|
try:
|
|
if notify_function is not None:
|
|
notify_function('info',
|
|
'Starting the {!r} VM...'.format(self.name))
|
|
self.start(start_guid=gui, notify_function=notify_function)
|
|
|
|
except (IOError, OSError, QubesException) as e:
|
|
raise QubesException(
|
|
'Error while starting the {!r} VM: {!s}'.format(
|
|
self.name, e))
|
|
except (MemoryError) as err:
|
|
raise QubesException('Not enough memory to start {!r} VM! '
|
|
'Close one or more running VMs and try again.'.format(
|
|
self.name))
|
|
|
|
if self.is_paused():
|
|
raise QubesException("VM is paused")
|
|
if not self.is_qrexec_running():
|
|
raise QubesException(
|
|
"Domain '{}': qrexec not connected.".format(self.name))
|
|
|
|
if gui and os.getenv("DISPLAY") is not None \
|
|
and not self.is_guid_running():
|
|
self.start_guid(verbose=verbose, notify_function=notify_function)
|
|
|
|
args = [system_path["qrexec_client_path"],
|
|
"-d", str(self.name),
|
|
'{}:{}'.format(user, command)]
|
|
if localcmd is not None:
|
|
args += ['-l', localcmd]
|
|
if filter_esc:
|
|
args += ['-t']
|
|
if os.isatty(sys.stderr.fileno()):
|
|
args += ['-T']
|
|
|
|
# TODO: QSB#13
|
|
if passio:
|
|
if os.name == 'nt':
|
|
# wait for qrexec-client to exit, otherwise client is not
|
|
# properly attached to console if qvm-run is executed from
|
|
# cmd.exe
|
|
ret = subprocess.call(args)
|
|
exit(ret)
|
|
os.execv(system_path["qrexec_client_path"], args)
|
|
exit(1)
|
|
|
|
call_kwargs = {}
|
|
if ignore_stderr:
|
|
null = open("/dev/null", "w")
|
|
call_kwargs['stderr'] = null
|
|
|
|
if passio_popen:
|
|
popen_kwargs = {'stdout': subprocess.PIPE}
|
|
popen_kwargs['stdin'] = subprocess.PIPE
|
|
if passio_stderr:
|
|
popen_kwargs['stderr'] = subprocess.PIPE
|
|
else:
|
|
popen_kwargs['stderr'] = call_kwargs.get('stderr', None)
|
|
p = subprocess.Popen(args, **popen_kwargs)
|
|
if null:
|
|
null.close()
|
|
return p
|
|
if not wait:
|
|
args += ["-e"]
|
|
retcode = subprocess.call(args, **call_kwargs)
|
|
if null:
|
|
null.close()
|
|
return retcode
|
|
|
|
|
|
def run_service(self, service, source=None, user=None,
|
|
passio_popen=False, input=None):
|
|
'''Run service on this VM
|
|
|
|
**passio_popen** and **input** are mutually exclusive.
|
|
|
|
:param str service: service name
|
|
:param qubes.vm.QubesVM: source domain as presented to this VM
|
|
:param str user: username to run service as
|
|
:param bool passio_popen: passed verbatim to :py:meth:`run`
|
|
:param str input: string passed as input to service
|
|
'''
|
|
|
|
if input is not None and passio_popen is not None:
|
|
raise ValueError("'input' and 'passio_popen' cannot be used "
|
|
"together")
|
|
|
|
source = 'dom0' if source is None else self.app.domains[source].name
|
|
|
|
# XXX TODO FIXME this looks bad...
|
|
if input:
|
|
return self.run("QUBESRPC %s %s" % (service, source),
|
|
localcmd="echo %s" % input, user=user, wait=True)
|
|
else:
|
|
return self.run("QUBESRPC %s %s" % (service, source),
|
|
passio_popen=passio_popen, user=user, wait=True)
|
|
|
|
|
|
|
|
def start_guid(self, extra_guid_args=[]):
|
|
'''Launch gui daemon.
|
|
|
|
GUI daemon securely displays windows from domain.
|
|
|
|
:param list extra_guid_args: Extra argv to pass to :program:`guid`.
|
|
'''
|
|
|
|
self.log.info('Starting gui daemon')
|
|
|
|
guid_cmd = [system_path["qubes_guid_path"],
|
|
"-d", str(self.xid), "-N", self.name,
|
|
"-c", self.label.color,
|
|
"-i", self.label.icon_path,
|
|
"-l", str(self.label.index)]
|
|
guid_cmd += extra_guid_args
|
|
|
|
if self.debug:
|
|
guid_cmd += ['-v', '-v']
|
|
|
|
# elif not verbose:
|
|
guid_cmd += ['-q']
|
|
|
|
retcode = subprocess.call(guid_cmd)
|
|
if retcode != 0:
|
|
raise QubesException('Cannot start qubes-guid!')
|
|
|
|
self.log.info('Sending monitor layout')
|
|
|
|
try:
|
|
subprocess.call(
|
|
[system_path['monitor_layout_notify_cmd'], self.name])
|
|
except Exception as e:
|
|
self.log.error('ERROR: {!s}'.format(e))
|
|
|
|
self.wait_for_session()
|
|
|
|
|
|
def start_qrexec_daemon(self):
|
|
'''Start qrexec daemon.
|
|
|
|
:raises OSError: when starting fails.
|
|
'''
|
|
|
|
self.log.debug('Starting the qrexec daemon')
|
|
qrexec_args = [str(self.xid), self.name, self.default_user]
|
|
if not self.debug:
|
|
qrexec_args.insert(0, "-q")
|
|
qrexec_env = os.environ.copy()
|
|
qrexec_env['QREXEC_STARTUP_TIMEOUT'] = str(self.qrexec_timeout)
|
|
retcode = subprocess.call([system_path["qrexec_daemon_path"]] +
|
|
qrexec_args, env=qrexec_env)
|
|
if retcode != 0:
|
|
raise OSError('Cannot execute qrexec-daemon!')
|
|
|
|
|
|
def start_qubesdb(self):
|
|
'''Start QubesDB daemon.
|
|
|
|
:raises OSError: when starting fails.
|
|
'''
|
|
|
|
self.log.info('Starting Qubes DB')
|
|
|
|
retcode = subprocess.call([
|
|
system_path["qubesdb_daemon_path"],
|
|
str(self.xid),
|
|
self.name])
|
|
if retcode != 0:
|
|
self.force_shutdown()
|
|
raise OSError("ERROR: Cannot execute qubesdb-daemon!")
|
|
|
|
|
|
def wait_for_session(self):
|
|
'''Wait until machine finished boot sequence.
|
|
|
|
This is done by executing qubes RPC call that checks if dummy system
|
|
service (which is started late in standard runlevel) is active.
|
|
'''
|
|
|
|
self.log.info('Waiting for qubes-session')
|
|
|
|
# Note : User root is redefined to SYSTEM in the Windows agent code
|
|
p = self.run('QUBESRPC qubes.WaitForSession none',
|
|
user="root", passio_popen=True, gui=False, wait=True)
|
|
p.communicate(input=self.default_user)
|
|
|
|
|
|
def create_on_disk(self, source_template=None):
|
|
'''Create files needed for VM.
|
|
|
|
:param qubes.vm.templatevm.TemplateVM source_template: Template to use
|
|
(if :py:obj:`None`, use domain's own template
|
|
'''
|
|
|
|
if source_template is None:
|
|
source_template = self.template
|
|
assert source_template is not None
|
|
|
|
self.storage.create_on_disk(verbose, source_template)
|
|
|
|
if self.updateable:
|
|
kernels_dir = source_template.kernels_dir
|
|
self.log.info(
|
|
'Copying the kernel (unset kernel to use it): {0}'.format(
|
|
kernels_dir))
|
|
|
|
os.mkdir(self.dir_path + '/kernels')
|
|
for f in ("vmlinuz", "initramfs", "modules.img"):
|
|
shutil.copy(os.path.join(kernels_dir, f),
|
|
os.path.join(self.dir_path,
|
|
qubes.config.vm_files["kernels_subdir"], f))
|
|
|
|
self.log.info('Creating icon symlink: {} -> {}'.format(
|
|
self.icon_path, self.label.icon_path))
|
|
if hasattr(os, "symlink"):
|
|
os.symlink(self.label.icon_path, self.icon_path)
|
|
else:
|
|
shutil.copy(self.label.icon_path, self.icon_path)
|
|
|
|
# fire hooks
|
|
self.fire_event('domain-created-on-disk', source_template)
|
|
|
|
|
|
def resize_private_img(self, size):
|
|
'''Resize private image.'''
|
|
|
|
# TODO QubesValueError, not assert
|
|
assert size >= self.get_private_img_sz(), "Cannot shrink private.img"
|
|
|
|
# resize the image
|
|
self.storage.resize_private_img(size)
|
|
|
|
# and then the filesystem
|
|
# FIXME move this to qubes.storage.xen.XenVMStorage
|
|
retcode = 0
|
|
if self.is_running():
|
|
retcode = self.run('''
|
|
while [ "`blockdev --getsize64 /dev/xvdb`" -lt {0} ]; do
|
|
head /dev/xvdb >/dev/null;
|
|
sleep 0.2;
|
|
done;
|
|
resize2fs /dev/xvdb'''.format(size), user="root", wait=True)
|
|
if retcode != 0:
|
|
raise QubesException("resize2fs failed")
|
|
|
|
|
|
def remove_from_disk(self):
|
|
'''Remove domain remnants from disk.'''
|
|
self.fire_event('domain-removed-from-disk')
|
|
self.storage.remove_from_disk()
|
|
|
|
|
|
def clone_disk_files(self, src):
|
|
'''Clone files from other vm.
|
|
|
|
:param qubes.vm.QubesVM src: source VM
|
|
'''
|
|
|
|
if src_vm.is_running():
|
|
raise QubesException("Attempt to clone a running VM!")
|
|
|
|
self.storage.clone_disk_files(src, verbose=False)
|
|
|
|
if srv.icon_path is not None \
|
|
and os.path.exists(src.dir_path) \
|
|
and self.icon_path is not None:
|
|
if os.path.islink(src.icon_path):
|
|
icon_path = os.readlink(src.icon_path)
|
|
self.log.info(
|
|
'Creating icon symlink {} -> {}'.format(
|
|
self.icon_path, icon_path))
|
|
os.symlink(icon_path, self.icon_path)
|
|
else:
|
|
self.log.info(
|
|
'Copying icon {} -> {}'.format(
|
|
src.icon_path, self.icon_path))
|
|
shutil.copy(src.icon_path, self.icon_path)
|
|
|
|
# fire hooks
|
|
self.fire_event('cloned-files', src)
|
|
|
|
|
|
# TODO maybe this should be other way: backend.devices['net'].attach(self)
|
|
def attach_network(self):
|
|
'''Attach network in this machine to it's netvm.'''
|
|
|
|
if not self.is_running():
|
|
raise QubesException("VM not running!")
|
|
|
|
if self.netvm is None:
|
|
raise QubesException("NetVM not set!")
|
|
|
|
if not netvm.is_running():
|
|
self.log.info('Starting NetVM ({0})'.format(netvm.name))
|
|
netvm.start()
|
|
|
|
self.libvirt_domain.attachDevice(lxml.etree.ElementTree(
|
|
self.lvxml_net_dev(self.ip, self.mac, self.netvm)).tostring())
|
|
|
|
|
|
def detach_network(self):
|
|
'''Detach machine from it's netvm'''
|
|
|
|
if not self.is_running():
|
|
raise QubesException("VM not running!")
|
|
|
|
if self.netvm is None:
|
|
raise QubesException("NetVM not set!")
|
|
|
|
|
|
self.libvirt_domain.detachDevice(lxml.etree.ElementTree(
|
|
self.lvxml_net_dev(self.ip, self.mac, self.netvm)).tostring())
|
|
|
|
|
|
#
|
|
# methods for querying domain state
|
|
#
|
|
|
|
# state of the machine
|
|
|
|
def get_power_state(self):
|
|
'''Return power state description string.
|
|
|
|
Return value may be one of those:
|
|
|
|
=============== ========================================================
|
|
return value meaning
|
|
=============== ========================================================
|
|
``'Halted'`` Machine is not active.
|
|
``'Transient'`` Machine is running, but does not have :program:`guid`
|
|
or :program:`qrexec` available.
|
|
``'Running'`` Machine is ready and running.
|
|
``'Paused'`` Machine is paused (currently not available, see below).
|
|
``'Suspended'`` Machine is S3-suspended.
|
|
``'Halting'`` Machine is in process of shutting down.
|
|
``'Dying'`` Machine crashed and is unusable.
|
|
``'Crashed'`` Machine crashed and is unusable, probably because of
|
|
bug in dom0.
|
|
``'NA'`` Machine is in unknown state (most likely libvirt domain
|
|
is undefined).
|
|
=============== ========================================================
|
|
|
|
``Paused`` state is currently unavailable because of missing code in
|
|
libvirt/xen glue.
|
|
|
|
FIXME: graph below may be incomplete and wrong. Click on method name to
|
|
see its documentation.
|
|
|
|
.. graphviz::
|
|
|
|
digraph {
|
|
node [fontname="sans-serif"];
|
|
edge [fontname="mono"];
|
|
|
|
|
|
Halted;
|
|
NA;
|
|
Dying;
|
|
Crashed;
|
|
Transient;
|
|
Halting;
|
|
Running;
|
|
Paused [color=gray75 fontcolor=gray75];
|
|
Suspended;
|
|
|
|
NA -> Halted;
|
|
Halted -> NA [constraint=false];
|
|
|
|
Halted -> Transient
|
|
[xlabel="start()" URL="#qubes.vm.qubesvm.QubesVM.start"];
|
|
Transient -> Running;
|
|
|
|
Running -> Halting
|
|
[xlabel="shutdown()"
|
|
URL="#qubes.vm.qubesvm.QubesVM.shutdown"
|
|
constraint=false];
|
|
Halting -> Dying -> Halted [constraint=false];
|
|
|
|
/* cosmetic, invisible edges to put rank constraint */
|
|
Dying -> Halting [style="invis"];
|
|
Halting -> Transient [style="invis"];
|
|
|
|
Running -> Halted
|
|
[label="force_shutdown()"
|
|
URL="#qubes.vm.qubesvm.QubesVM.force_shutdown"
|
|
constraint=false];
|
|
|
|
Running -> Crashed [constraint=false];
|
|
Crashed -> Halted [constraint=false];
|
|
|
|
Running -> Paused
|
|
[label="pause()" URL="#qubes.vm.qubesvm.QubesVM.pause"
|
|
color=gray75 fontcolor=gray75];
|
|
Running -> Suspended
|
|
[label="pause()" URL="#qubes.vm.qubesvm.QubesVM.pause"
|
|
color=gray50 fontcolor=gray50];
|
|
Paused -> Running
|
|
[label="unpause()" URL="#qubes.vm.qubesvm.QubesVM.unpause"
|
|
color=gray75 fontcolor=gray75];
|
|
Suspended -> Running
|
|
[label="unpause()" URL="#qubes.vm.qubesvm.QubesVM.unpause"
|
|
color=gray50 fontcolor=gray50];
|
|
|
|
Running -> Suspended
|
|
[label="suspend()" URL="#qubes.vm.qubesvm.QubesVM.suspend"];
|
|
Suspended -> Running
|
|
[label="resume()" URL="#qubes.vm.qubesvm.QubesVM.resume"];
|
|
|
|
|
|
{ rank=source; Halted NA };
|
|
{ rank=same; Transient Halting };
|
|
{ rank=same; Crashed Dying };
|
|
{ rank=sink; Paused Suspended };
|
|
}
|
|
|
|
.. seealso::
|
|
http://wiki.libvirt.org/page/VM_lifecycle
|
|
Description of VM life cycle from the point of view of libvirt.
|
|
|
|
https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainState
|
|
Libvirt API for changing state of a domain.
|
|
|
|
'''
|
|
|
|
libvirt_domain = self.libvirt_domain
|
|
if libvirt_domain is None:
|
|
return "NA"
|
|
|
|
if libvirt_domain.isActive():
|
|
if libvirt_domain.state()[0] == libvirt.VIR_DOMAIN_PAUSED:
|
|
return "Paused"
|
|
elif libvirt_domain.state()[0] == libvirt.VIR_DOMAIN_CRASHED:
|
|
return "Crashed"
|
|
elif libvirt_domain.state()[0] == libvirt.VIR_DOMAIN_SHUTDOWN:
|
|
return "Halting"
|
|
elif libvirt_domain.state()[0] == libvirt.VIR_DOMAIN_SHUTOFF:
|
|
return "Dying"
|
|
elif libvirt_domain.state()[0] == libvirt.VIR_DOMAIN_PMSUSPENDED:
|
|
return "Suspended"
|
|
else:
|
|
if not self.is_fully_usable():
|
|
return "Transient"
|
|
else:
|
|
return "Running"
|
|
else:
|
|
return 'Halted'
|
|
|
|
return "NA"
|
|
|
|
|
|
def is_running(self):
|
|
'''Check whether this domain is running.
|
|
|
|
:returns: :py:obj:`True` if this domain is started, \
|
|
:py:obj:`False` otherwise.
|
|
:rtype: bool
|
|
'''
|
|
|
|
return self.libvirt_domain and self.libvirt_domain.isActive()
|
|
|
|
|
|
def is_paused(self):
|
|
'''Check whether this domain is paused.
|
|
|
|
:returns: :py:obj:`True` if this domain is paused, \
|
|
:py:obj:`False` otherwise.
|
|
:rtype: bool
|
|
'''
|
|
|
|
return self.libvirt_domain \
|
|
and self.libvirt_domain.state() == libvirt.VIR_DOMAIN_PAUSED
|
|
|
|
|
|
def is_guid_running(self):
|
|
'''Check whether gui daemon for this domain is available.
|
|
|
|
:returns: :py:obj:`True` if guid is running, \
|
|
:py:obj:`False` otherwise.
|
|
:rtype: bool
|
|
'''
|
|
xid = self.xid
|
|
if xid < 0:
|
|
return False
|
|
if not os.path.exists('/var/run/qubes/guid-running.%d' % xid):
|
|
return False
|
|
return True
|
|
|
|
|
|
def is_qrexec_running(self):
|
|
'''Check whether qrexec for this domain is available.
|
|
|
|
:returns: :py:obj:`True` if qrexec is running, \
|
|
:py:obj:`False` otherwise.
|
|
:rtype: bool
|
|
'''
|
|
if self.xid < 0:
|
|
return False
|
|
return os.path.exists('/var/run/qubes/qrexec.%s' % self.name)
|
|
|
|
|
|
def is_fully_usable(self):
|
|
'''Check whether domain is running and sane.
|
|
|
|
Currently this checks for running guid and qrexec.
|
|
|
|
:returns: :py:obj:`True` if qrexec is running, \
|
|
:py:obj:`False` otherwise.
|
|
:rtype: bool
|
|
'''
|
|
|
|
# Running gui-daemon implies also VM running
|
|
if not self.is_guid_running():
|
|
return False
|
|
if not self.is_qrexec_running():
|
|
return False
|
|
return True
|
|
|
|
|
|
# memory and disk
|
|
|
|
def get_mem(self):
|
|
'''Get current memory usage from VM.
|
|
|
|
:returns: Memory usage [FIXME unit].
|
|
:rtype: FIXME
|
|
'''
|
|
|
|
if self.libvirt_domain is None:
|
|
return 0
|
|
if not self.libvirt_domain.isActive():
|
|
return 0
|
|
|
|
return self.libvirt_domain.info()[1]
|
|
|
|
|
|
def get_mem_static_max(self):
|
|
'''Get maximum memory available to VM.
|
|
|
|
:returns: Memory limit [FIXME unit].
|
|
:rtype: FIXME
|
|
'''
|
|
|
|
if self.libvirt_domain is None:
|
|
return 0
|
|
|
|
return self.libvirt_domain.maxMemory()
|
|
|
|
|
|
def get_per_cpu_time(self):
|
|
'''Get total CPU time burned by this domain since start.
|
|
|
|
:returns: CPU time usage [FIXME unit].
|
|
:rtype: FIXME
|
|
'''
|
|
|
|
if self.libvirt_domain is None:
|
|
return 0
|
|
if not self.libvirt_domain.isActive():
|
|
return 0
|
|
|
|
return libvirt_domain.getCPUStats(
|
|
libvirt.VIR_NODE_CPU_STATS_ALL_CPUS, 0)[0]['cpu_time']/10**9
|
|
|
|
|
|
# XXX shouldn't this go only to vms that have root image?
|
|
def get_disk_utilization_root_img(self):
|
|
'''Get space that is actually ocuppied by :py:attr:`root_img`.
|
|
|
|
Root image is a sparse file, so it is probably much less than logical
|
|
available space.
|
|
|
|
:returns: domain's real disk image size [FIXME unit]
|
|
:rtype: FIXME
|
|
|
|
.. seealso:: :py:meth:`get_root_img_sz`
|
|
'''
|
|
|
|
return qubes.utils.get_disk_usage(self.root_img)
|
|
|
|
|
|
# XXX shouldn't this go only to vms that have root image?
|
|
def get_root_img_sz(self):
|
|
'''Get image size of :py:attr:`root_img`.
|
|
|
|
Root image is a sparse file, so it is probably much more than ocuppied
|
|
physical space.
|
|
|
|
:returns: domain's virtual disk size [FIXME unit]
|
|
:rtype: FIXME
|
|
|
|
.. seealso:: :py:meth:`get_disk_utilization_root_img`
|
|
'''
|
|
|
|
if not os.path.exists(self.root_img):
|
|
return 0
|
|
|
|
return os.path.getsize(self.root_img)
|
|
|
|
|
|
def get_disk_utilization_private_img(self):
|
|
'''Get space that is actually ocuppied by :py:attr:`private_img`.
|
|
|
|
Private image is a sparse file, so it is probably much less than
|
|
logical available space.
|
|
|
|
:returns: domain's real disk image size [FIXME unit]
|
|
:rtype: FIXME
|
|
|
|
.. seealso:: :py:meth:`get_private_img_sz`
|
|
'''
|
|
|
|
return qubes.utils.get_disk_usage(self.private_img)
|
|
|
|
|
|
def get_private_img_sz(self):
|
|
'''Get image size of :py:attr:`private_img`.
|
|
|
|
Private image is a sparse file, so it is probably much more than
|
|
ocuppied physical space.
|
|
|
|
:returns: domain's virtual disk size [FIXME unit]
|
|
:rtype: FIXME
|
|
|
|
.. seealso:: :py:meth:`get_disk_utilization_private_img`
|
|
'''
|
|
|
|
return self.storage.get_private_img_sz()
|
|
|
|
|
|
def get_disk_utilization(self):
|
|
'''Return total space actually occuppied by all files belonging to \
|
|
this domain.
|
|
|
|
:returns: domain's total disk usage [FIXME unit]
|
|
:rtype: FIXME
|
|
'''
|
|
|
|
return qubes.utils.get_disk_usage(self.dir_path)
|
|
|
|
|
|
def verify_files(self):
|
|
'''Verify that files accessed by this machine are sane.
|
|
|
|
On success, returns normally. On failure, raises exception.
|
|
'''
|
|
|
|
self.storage.verify_files()
|
|
|
|
if not os.path.exists(os.path.join(self.kernels_dir, 'vmlinuz')):
|
|
raise QubesException(
|
|
"VM kernel does not exist: {0}".\
|
|
format(os.path.join(self.kernels_dir, 'vmlinuz')))
|
|
|
|
if not os.path.exists(os.path.join(self.kernels_dir, 'initramfs')):
|
|
raise QubesException(
|
|
"VM initramfs does not exist: {0}".\
|
|
format(os.path.join(self.kernels_dir, 'initramfs')))
|
|
|
|
self.fire_event('verify-files')
|
|
|
|
return True
|
|
|
|
|
|
# miscellanous
|
|
|
|
def get_start_time(self):
|
|
'''Tell when machine was started.
|
|
|
|
:rtype: datetime.datetime
|
|
'''
|
|
if not self.is_running():
|
|
return None
|
|
|
|
# TODO shouldn't this be qubesdb?
|
|
start_time = self.app.vmm.xs.read('',
|
|
'/vm/{}/start_time'.format(self.uuid))
|
|
if start_time != '':
|
|
return datetime.datetime.fromtimestamp(float(start_time))
|
|
else:
|
|
return None
|
|
|
|
|
|
# XXX this probably should go to AppVM
|
|
def is_outdated(self):
|
|
'''Check whether domain needs restart to update root image from \
|
|
template.
|
|
|
|
:returns: :py:obj:`True` if is outdated, :py:obj:`False` otherwise.
|
|
:rtype: bool
|
|
'''
|
|
|
|
# Makes sense only on VM based on template
|
|
if self.template is None:
|
|
return False
|
|
|
|
if not self.is_running():
|
|
return False
|
|
|
|
if not hasattr(self.template, 'rootcow_img'):
|
|
return False
|
|
|
|
rootimg_inode = os.stat(self.template.root_img)
|
|
try:
|
|
rootcow_inode = os.stat(self.template.rootcow_img)
|
|
except OSError:
|
|
# The only case when rootcow_img doesn't exists is in the middle of
|
|
# commit_changes, so VM is outdated right now
|
|
return True
|
|
|
|
current_dmdev = "/dev/mapper/snapshot-{0:x}:{1}-{2:x}:{3}".format(
|
|
rootimg_inode[2], rootimg_inode[1],
|
|
rootcow_inode[2], rootcow_inode[1])
|
|
|
|
# FIXME
|
|
# 51712 (0xCA00) is xvda
|
|
# backend node name not available through xenapi :(
|
|
used_dmdev = vmm.xs.read('',
|
|
'/local/domain/0/backend/vbd/{}/51712/node'.format(self.xid))
|
|
|
|
return used_dmdev != current_dmdev
|
|
|
|
|
|
def is_networked(self):
|
|
'''Check whether this VM can reach network (firewall notwithstanding).
|
|
|
|
:returns: :py:obj:`True` if is machine can reach network, \
|
|
:py:obj:`False` otherwise.
|
|
:rtype: bool
|
|
'''
|
|
|
|
if self.provides_network:
|
|
return True
|
|
|
|
return self.netvm is not None
|
|
|
|
|
|
#
|
|
# helper methods
|
|
#
|
|
|
|
def relative_path(self, path):
|
|
'''Return path relative to py:attr:`dir_path`.
|
|
|
|
:param str path: Path in question.
|
|
:returns: Relative path.
|
|
'''
|
|
|
|
return os.path.relpath(path, self.dir_path)
|
|
# return arg.replace(self.dir_path + '/', '')
|
|
|
|
|
|
def create_qdb_entries(self):
|
|
'''Create entries in Qubes DB.
|
|
'''
|
|
self.qdb.write("/name", self.name)
|
|
self.qdb.write("/qubes-vm-type", self.type)
|
|
self.qdb.write("/qubes-vm-updateable", str(self.updateable))
|
|
|
|
if self.provides_network:
|
|
self.qdb.write("/qubes-netvm-gateway", self.gateway)
|
|
self.qdb.write("/qubes-netvm-secondary-dns", self.secondary_dns)
|
|
self.qdb.write("/qubes-netvm-netmask", self.netmask)
|
|
self.qdb.write("/qubes-netvm-network", self.network)
|
|
|
|
if self.netvm is not None:
|
|
self.qdb.write("/qubes-ip", self.ip)
|
|
self.qdb.write("/qubes-netmask", self.netvm.netmask)
|
|
self.qdb.write("/qubes-gateway", self.netvm.gateway)
|
|
self.qdb.write("/qubes-secondary-dns", self.netvm.secondary_dns)
|
|
|
|
tzname = qubes.utils.get_timezone()
|
|
if tzname:
|
|
self.qdb.write("/qubes-timezone", tzname)
|
|
|
|
for srv in self.services.keys():
|
|
# convert True/False to "1"/"0"
|
|
self.qdb.write("/qubes-service/{0}".format(srv),
|
|
str(int(self.services[srv])))
|
|
|
|
self.qdb.write("/qubes-block-devices", '')
|
|
|
|
self.qdb.write("/qubes-usb-devices", '')
|
|
|
|
self.qdb.write("/qubes-debug-mode", str(int(self.debug)))
|
|
|
|
# TODO: Currently the whole qmemman is quite Xen-specific, so stay with
|
|
# xenstore for it until decided otherwise
|
|
if qmemman_present:
|
|
vmm.xs.set_permissions('',
|
|
'/local/domain/{}/memory'.format(self.xid),
|
|
[{'dom': self.xid}])
|
|
|
|
self.fire_event('qdb-created')
|
|
|
|
|
|
def _update_libvirt_domain(self):
|
|
'''Re-initialise :py:attr:`libvirt_domain`.'''
|
|
domain_config = self.create_config_file()
|
|
if self._libvirt_domain is not None:
|
|
self._libvirt_domain.undefine()
|
|
try:
|
|
self._libvirt_domain = vmm.libvirt_conn.defineXML(domain_config)
|
|
self.uuid = uuid.UUID(bytes=self._libvirt_domain.UUID())
|
|
except libvirt.libvirtError:
|
|
if vmm.libvirt_conn.virConnGetLastError()[0] == \
|
|
libvirt.VIR_ERR_NO_DOMAIN:
|
|
# accept the fact that libvirt doesn't know anything about this
|
|
# domain...
|
|
pass
|
|
else:
|
|
raise
|
|
|
|
|
|
def cleanup_vifs(self):
|
|
'''Remove stale network device backends.
|
|
|
|
Xend does not remove vif when backend domain is down, so we must do it
|
|
manually.
|
|
'''
|
|
|
|
# FIXME: remove this?
|
|
if not self.is_running():
|
|
return
|
|
|
|
dev_basepath = '/local/domain/%d/device/vif' % self.xid
|
|
for dev in self.app.vmm.xs.ls('', dev_basepath):
|
|
# check if backend domain is alive
|
|
backend_xid = int(self.app.vmm.xs.read('',
|
|
'{}/{}/backend-id'.format(dev_basepath, dev)))
|
|
if backend_xid in self.app.vmm.libvirt_conn.listDomainsID():
|
|
# check if device is still active
|
|
if self.app.vmm.xs.read('',
|
|
'{}/{}/state'.format(dev_basepath, dev)) == '4':
|
|
continue
|
|
# remove dead device
|
|
self.app.vmm.xs.rm('', '{}/{}'.format(dev_basepath, dev))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#
|
|
# workshop -- those are to be reworked later
|
|
#
|
|
|
|
def get_prefmem(self):
|
|
# TODO: qmemman is still xen specific
|
|
untrusted_meminfo_key = xs.read('', '/local/domain/%s/memory/meminfo'
|
|
% self.xid)
|
|
if untrusted_meminfo_key is None or untrusted_meminfo_key == '':
|
|
return 0
|
|
domain = qmemman.DomainState(self.xid)
|
|
qmemman_algo.refresh_meminfo_for_domain(domain, untrusted_meminfo_key)
|
|
domain.memory_maximum = self.get_mem_static_max()*1024
|
|
return qmemman_algo.prefmem(domain)/1024
|
|
|
|
|
|
|
|
#
|
|
# landfill -- those are unneeded
|
|
#
|
|
|
|
|
|
|
|
|
|
# attrs = {
|
|
# XXX probably will be obsoleted by .events_enabled
|
|
# "_do_not_reset_firewall": { "func": lambda x: False },
|
|
|
|
# XXX WTF?
|
|
# "kernels_dir": {
|
|
# # for backward compatibility (or another rare case): kernel=None ->
|
|
# # kernel in VM dir
|
|
# "func": lambda x: \
|
|
# os.path.join(system_path["qubes_kernels_base_dir"],
|
|
# self.kernel) if self.kernel is not None \
|
|
# else os.path.join(self.dir_path,
|
|
# vm_files["kernels_subdir"]) },
|
|
# "_start_guid_first": { "func": lambda x: False },
|
|
# }
|
|
|
|
# this function appears unused
|
|
# def _cleanup_zombie_domains(self):
|
|
# """
|
|
# This function is workaround broken libxl (which leaves not fully
|
|
# created domain on failure) and vchan on domain crash behaviour
|
|
# @return: None
|
|
# """
|
|
# xc = self.get_xc_dominfo()
|
|
# if xc and xc['dying'] == 1:
|
|
# # GUID still running?
|
|
# guid_pidfile = '/var/run/qubes/guid-running.%d' % xc['domid']
|
|
# if os.path.exists(guid_pidfile):
|
|
# guid_pid = open(guid_pidfile).read().strip()
|
|
# os.kill(int(guid_pid), 15)
|
|
# # qrexec still running?
|
|
# if self.is_qrexec_running():
|
|
# #TODO: kill qrexec daemon
|
|
# pass
|