1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660 |
- #!/usr/bin/python2 -O
- # -*- coding: utf-8 -*-
- # The Qubes OS Project, http://www.qubes-os.org
- #
- # Copyright (C) 2010 Joanna Rutkowska <joanna@invisiblethingslab.com>
- # Copyright (C) 2013 Marek Marczykowski <marmarek@invisiblethingslab.com>
- # Copyright (C) 2014 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.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.MAX_QID:
- raise ValueError(
- '{} value must be between 0 and qubes.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
- 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.property('netvm', load_stage=4,
- 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 :py:obj:`False`, machine is disconnected. '
- 'When :py:obj:`None` (or absent), domain uses default NetVM.')
- provides_network = qubes.property('provides_network', type=bool,
- doc=':py:obj:`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.')
- dir_path = qubes.property('dir_path', type=str, default=None,
- doc='FIXME')
- conf_file = qubes.property('conf_file', type=str,
- default=(lambda self: self.name + '.conf'),
- saver=(lambda self, prop, value: self.relative_path(value)),
- doc='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, default=False,
- setter=qubes.property.bool,
- 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 memory balancer).')
- internal = qubes.property('internal', type=bool, default=False,
- setter=qubes.property.bool,
- doc="Internal VM (not shown in qubes-manager, doesn'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 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', type=bool, default=False,
- setter=qubes.property.bool,
- doc='Setting this to :py:obj:`True` means that VM should be autostarted on dom0 boot.')
- # XXX I don't understand backups
- include_in_backups = qubes.property('include_in_backups', type=bool, default=True,
- setter=qubes.property.bool,
- doc='If this domain is to be included in default backup.')
- backup_content = qubes.property('backup_content', type=bool, default=False,
- 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
- 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 self.conf_file != self.absolute_path(self.name + ".conf", None)
- @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):
- super(QubesVM, self).__init__(app, xml)
- #Init private attrs
- self._libvirt_domain = None
- self._qdb_connection = None
- assert self.__qid < qubes_max_qid, "VM id out of bounds!"
- assert self.name is not None
- if not self.verify_name(self.name):
- msg = ("'%s' is invalid VM name (invalid characters, over 31 chars long, "
- "or one of 'none', 'true', 'false')") % self.name
- if xml is not None:
- print >>sys.stderr, "WARNING: %s" % msg
- else:
- raise QubesException(msg)
- # 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
- # XXX what?! -woju
- 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.config.defaults["storage_class"](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.on_property_set_netvm(self, event, name, 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-set:name')
- def on_property_set_name(self, event, name, new_name, old_name=None):
- if self.libvirt_domain:
- self.libvirt_domain.undefine()
- self._libvirt_domain = None
- if self._qdb_connection:
- self._qdb_connection.close()
- self._qdb_connection = None
- new_conf = os.path.join(self.dir_path, new_name + '.conf')
- if os.path.exists(self.conf_file):
- os.rename(self.conf_file, new_conf)
- old_dirpath = self.dir_path
- self.storage.rename(self.name, name)
- new_dirpath = self.storage.vmdir
- self.dir_path = new_dirpath
- if self.conf_file is not None:
- self.conf_file = new_conf.replace(old_dirpath, new_dirpath)
- 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()
- self.post_rename(old_name)
- @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:
- 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
- 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("ERROR: Failed to connect to qmemman: %s" % str(e))
- if not got_memory:
- qmemman_client.close()
- raise MemoryError("ERROR: insufficient memory to start VM '%s'" % 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:
- # allready 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 '{0}' VM...".format(self.name))
- self.start(start_guid=gui, notify_function=notify_function)
- except (IOError, OSError, QubesException) as err:
- raise QubesException("Error while starting the '{0}' VM: {1}".format(self.name, err))
- except (MemoryError) as err:
- raise QubesException("Not enough memory to start '{0}' 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), "%s:%s" % (user, command)]
- if localcmd is not None:
- args += [ "-l", localcmd]
- if filter_esc:
- args += ["-t"]
- if os.isatty(sys.stderr.fileno()):
- args += ["-T"]
- 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
- 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
- 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: {0} -> {1}'.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
- retcode = 0
- if self.is_running():
- retcode = self.run("while [ \"`blockdev --getsize64 /dev/xvdb`\" -lt {0} ]; do ".format(size) +
- "head /dev/xvdb > /dev/null; sleep 0.2; done; resize2fs /dev/xvdb", 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.xml_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.xml_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
- .. seealso:: https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainState
- '''
- 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/%s/start_time" % str(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/{0}/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
- #
- # TODO deprecate `default`
- def absolute_path(self, path, default):
- '''Return specified path as absolute path.
- Relative paths are relative to :py:attr:`dir_path`. Absolute path are left unchanged.
- :param str path: Path in question (possibly relatve).
- :param default: What to return if ``arg`` is :py:obj:`None`.
- :returns: Absolute path.
- '''
- if arg is not None and os.path.isabs(arg):
- return arg
- else:
- return os.path.join(self.dir_path, (arg if arg is not None else default))
- 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/{0}/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:
- 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('', '%s/%s/backend-id' % (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('', '%s/%s/state' % (dev_basepath, dev)) == '4':
- continue
- # remove dead device
- self.app.vmm.xs.rm('', '%s/%s' % (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 = {
- #
- ##### Internal attributes - will be overriden in __init__ regardless of args
- # those should be __builtin__.property of something
- # used to suppress side effects of clone_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
|