123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256 |
- #
- # 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 library is free software; you can redistribute it and/or
- # modify it under the terms of the GNU Lesser General Public
- # License as published by the Free Software Foundation; either
- # version 2.1 of the License, or (at your option) any later version.
- #
- # This library 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
- # Lesser General Public License for more details.
- #
- # You should have received a copy of the GNU Lesser General Public
- # License along with this library; if not, see <https://www.gnu.org/licenses/>.
- #
- import asyncio
- import base64
- import grp
- import os
- import os.path
- import shutil
- import string
- import subprocess
- import uuid
- import libvirt # pylint: disable=import-error
- import lxml
- import qubes
- import qubes.config
- import qubes.exc
- import qubes.storage
- import qubes.storage.file
- import qubes.utils
- import qubes.vm
- import qubes.vm.mix.net
- qmemman_present = False
- try:
- import qubes.qmemman.client # pylint: disable=wrong-import-position
- qmemman_present = True
- except ImportError:
- pass
- # overhead of per-qube/per-vcpu Xen structures,
- # taken from OpenStack nova/virt/xenapi/driver.py
- # see https://wiki.openstack.org/wiki/XenServer/Overhead
- # add an extra MB because Nova rounds up to MBs
- MEM_OVERHEAD_BASE = (3 + 1) * 1024 * 1024
- MEM_OVERHEAD_PER_VCPU = 3 * 1024 * 1024 / 2
- def _setter_kernel(self, prop, value):
- """ Helper for setting the domain kernel and running sanity checks on it.
- """ # pylint: disable=unused-argument
- if not value:
- return ''
- value = str(value)
- if '/' in value:
- raise qubes.exc.QubesPropertyValueError(
- self, prop, value,
- 'Kernel name cannot contain \'/\'')
- return value
- def _setter_positive_int(self, prop, value):
- """ Helper for setting a positive int. Checks that the int is > 0 """
- # pylint: disable=unused-argument
- value = int(value)
- if value <= 0:
- raise ValueError('Value must be positive')
- return value
- def _setter_non_negative_int(self, prop, value):
- """ Helper for setting a positive int. Checks that the int is >= 0 """
- # pylint: disable=unused-argument
- value = int(value)
- if value < 0:
- raise ValueError('Value must be positive or zero')
- return value
- def _setter_default_user(self, prop, value):
- """ Helper for setting default user """
- value = str(value)
- # specifically forbid: ':', ' ', """, '"'
- allowed_chars = string.ascii_letters + string.digits + '_-+,.'
- if not all(c in allowed_chars for c in value):
- raise qubes.exc.QubesPropertyValueError(
- self, prop, value,
- 'Username can contain only those characters: ' + allowed_chars)
- return value
- def _setter_virt_mode(self, prop, value):
- value = str(value)
- value = value.lower()
- if value not in ('hvm', 'pv', 'pvh'):
- raise qubes.exc.QubesPropertyValueError(
- self, prop, value,
- 'Invalid virtualization mode, supported values: hvm, pv, pvh')
- if value == 'pvh' and list(self.devices['pci'].persistent()):
- raise qubes.exc.QubesPropertyValueError(
- self, prop, value,
- "pvh mode can't be set if pci devices are attached")
- return value
- def _default_virt_mode(self):
- if self.devices['pci'].persistent():
- return 'hvm'
- try:
- return self.template.virt_mode
- except AttributeError:
- return 'pvh'
- def _default_with_template(prop, default):
- """Return a callable for 'default' argument of a property. Use a value
- from a template (if any), otherwise *default*
- """
- def _func(self):
- try:
- return getattr(self.template, prop)
- except AttributeError:
- if callable(default):
- return default(self)
- return default
- return _func
- def _default_maxmem(self):
- # first check for any reason to _not_ enable qmemman
- if not self.is_memory_balancing_possible():
- return 0
- # 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.features.get('os', None) == 'Linux':
- default_maxmem = self.memory * 10
- else:
- default_maxmem = 4000
- # don't use default larger than half of physical ram
- default_maxmem = min(default_maxmem,
- int(self.app.host.memory_total / 1024 / 2))
- return _default_with_template('maxmem', default_maxmem)(self)
- def _default_kernelopts(self):
- """
- Return default kernel options for the given kernel. If kernel directory
- contains 'default-kernelopts-{pci,nopci}.txt' file, use that. Otherwise
- use built-in defaults.
- For qubes without PCI devices, kernelopts of qube's template are
- considered (for template-based qubes).
- """
- if not self.kernel:
- return ''
- if 'kernel' in self.volumes:
- kernels_dir = self.storage.kernels_dir
- else:
- kernels_dir = os.path.join(
- qubes.config.system_path['qubes_kernels_base_dir'],
- self.kernel)
- pci = bool(list(self.devices['pci'].persistent()))
- if pci:
- path = os.path.join(kernels_dir, 'default-kernelopts-pci.txt')
- else:
- try:
- return self.template.kernelopts
- except AttributeError:
- pass
- path = os.path.join(kernels_dir, 'default-kernelopts-nopci.txt')
- if os.path.exists(path):
- with open(path) as f_kernelopts:
- return f_kernelopts.read().strip()
- else:
- return (qubes.config.defaults['kernelopts_pcidevs'] if pci else
- qubes.config.defaults['kernelopts'])
- class QubesVM(qubes.vm.mix.net.NetVMMixin, qubes.vm.BaseVM):
- """Base functionality of Qubes VM shared between all VMs.
- The following events are raised on this class or its subclasses:
- .. event:: domain-init (subject, event)
- Fired at the end of class' constructor.
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'domain-init'``)
- .. event:: domain-load (subject, event)
- Fired after the qube was loaded from :file:`qubes.xml`
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'domain-loaded'``)
- .. event:: domain-pre-start \
- (subject, event, start_guid, mem_required)
- Fired at the beginning of :py:meth:`start` method.
- Handler for this event can be asynchronous (a coroutine).
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'domain-pre-start'``)
- *other arguments are as in :py:meth:`start`*
- .. event:: domain-spawn (subject, event, start_guid)
- Fired after creating libvirt domain.
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'domain-spawn'``)
- Handler for this event can be asynchronous (a coroutine).
- *other arguments are as in :py:meth:`start`*
- .. event:: domain-start (subject, event, start_guid)
- Fired at the end of :py:meth:`start` method.
- Handler for this event can be asynchronous (a coroutine).
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'domain-start'``)
- *other arguments are as in :py:meth:`start`*
- .. event:: domain-start-failed (subject, event, reason)
- Fired when :py:meth:`start` method fails.
- *reason* argument is a textual error message.
- Handler for this event can be asynchronous (a coroutine).
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'domain-start-failed'``)
- .. event:: domain-paused (subject, event)
- Fired when the domain has been paused.
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'domain-paused'``)
- .. event:: domain-unpaused (subject, event)
- Fired when the domain has been unpaused.
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'domain-unpaused'``)
- .. event:: domain-stopped (subject, event)
- Fired when domain has been stopped.
- This event is emitted before ``'domain-shutdown'`` and will trigger
- the cleanup in QubesVM. So if you require that the cleanup has
- already run use ``'domain-shutdown'``.
- Note that you can receive this event as soon as you received
- ``'domain-pre-start'``. This also can be emitted in case of a
- startup failure, before or after ``'domain-start-failed'``.
- Handler for this event can be asynchronous (a coroutine).
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'domain-stopped'``)
- .. event:: domain-shutdown (subject, event)
- Fired when domain has been shut down. It is generated after
- ``'domain-stopped'``.
- Note that you can receive this event as soon as you received
- ``'domain-pre-start'``. This also can be emitted in case of a
- startup failure, before or after ``'domain-start-failed'``.
- Handler for this event can be asynchronous (a coroutine).
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'domain-shutdown'``)
- .. event:: domain-pre-shutdown (subject, event, force)
- Fired at the beginning of :py:meth:`shutdown` method.
- Handler for this event can be asynchronous (a coroutine).
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'domain-pre-shutdown'``)
- :param force: If the shutdown is to be forceful
- .. event:: domain-shutdown-failed (subject, event, reason)
- Fired when ``domain-pre-shutdown`` event was sent, but the actual
- shutdown operation failed. It can be caused by other
- ``domain-pre-shutdown`` handler blocking the operation with an
- exception, or a shutdown timeout.
- Handler for this event can be asynchronous (a coroutine).
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'domain-shutdown-failed'``)
- :param reason: Error message
- .. event:: domain-cmd-pre-run (subject, event, start_guid)
- Fired at the beginning of :py:meth:`run_service` method.
- Handler for this event can be asynchronous (a coroutine).
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'domain-cmd-pre-run'``)
- :param start_guid: If the gui daemon can be started
- .. event:: domain-create-on-disk (subject, event)
- Fired at the end of :py:meth:`create_on_disk` method.
- Handler for this event can be asynchronous (a coroutine).
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'domain-create-on-disk'``)
- .. event:: domain-remove-from-disk (subject, event)
- Fired at the beginning of :py:meth:`remove_from_disk` method, before
- the qube directory is removed.
- Handler for this event can be asynchronous (a coroutine).
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'domain-remove-from-disk'``)
- .. event:: domain-clone-files (subject, event, src)
- Fired at the end of :py:meth:`clone_disk_files` method.
- Handler for this event can be asynchronous (a coroutine).
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'domain-clone-files'``)
- :param src: source qube
- .. event:: domain-verify-files (subject, event)
- Fired at the end of :py:meth:`clone_disk_files` method.
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'domain-verify-files'``)
- If you think some files are missing or damaged, raise an exception.
- .. event:: domain-is-fully-usable (subject, event)
- Fired at the end of :py:meth:`clone_disk_files` method.
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'domain-is-fully-usable'``)
- You may ``yield False`` from the handler if you think the qube is
- not fully usable. This will cause the domain to be in "transient"
- state in the domain lifecycle.
- .. event:: domain-qdb-create (subject, event)
- Fired at the end of :py:meth:`create_qdb_entries` method.
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'domain-qdb-create'``)
- This event is a good place to add your custom entries to the qdb.
- .. event:: domain-qdb-change:watched-path (subject, event, path)
- Fired when watched QubesDB entry is changed. See
- :py:meth:`watch_qdb_path`. *watched-path* part of event name is
- what path was registered for watching, *path* in event argument
- is what actually have changed (which may be different if watching a
- directory, i.e. a path with `/` at the end).
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'domain-qdb-change'``)
- :param path: changed QubesDB path
- .. event:: backup-get-files (subject, event)
- Collects additional file to be included in a backup.
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'backup-get-files'``)
- Handlers should yield paths of the files.
- .. event:: domain-restore (subject, event)
- Domain was just restored from backup, although the storage was not
- yet verified and the app object was not yet saved.
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'domain-restore'``)
- .. event:: domain-feature-set:feature (subject, event, feature, value
- [, oldvalue])
- A feature was changed. This event is fired before bare
- `domain-feature-set` event.
- *oldvalue* is present only when there was any.
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'domain-feature-set:' feature``)
- :param feature: feature name
- :param value: new value
- :param oldvalue: old value, if any
- .. event:: domain-feature-delete:feature (subject, event, feature)
- A feature was removed. This event is fired before bare
- `domain-feature-delete` event.
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'domain-feature-delete:' feature``)
- :param feature: feature name
- .. event:: domain-tag-add:tag (subject, event, tag)
- A tag was added.
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'domain-tag-add:' tag``)
- :param tag: tag name
- .. event:: domain-tag-delete:tag (subject, event, tag)
- A feature was removed.
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'domain-tag-delete:' tag``)
- :param tag: tag name
- .. event:: features-request (subject, event, *, untrusted_features)
- The domain is performing a features request.
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'features-request'``)
- :param untrusted_features: :py:class:`dict` containing the feature \
- request
- The content of the `untrusted_features` variable is, as the name
- implies, **UNTRUSTED**. The remind this to programmer, the variable
- name has to be exactly as provided.
- It is up to the extensions to decide, what to do with request,
- ranging from plainly ignoring the request to verbatim copy into
- :py:attr:`features` with only minimal sanitisation.
- Handler for this event can be asynchronous (a coroutine).
- .. event:: firewall-changed (subject, event)
- Firewall was changed.
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'firewall-changed'``)
- .. event:: net-domain-connect (subject, event, vm)
- Fired after connecting a domiain to this vm.
- :param subject: Event emitter (the qube object)
- :param event: Event name (``'net-domain-connect'``)
- :param vm: The domain that was just connected.
- On the `vm` object there was probably ``property-set:netvm`` fired
- earlier.
- .. event:: template-postinstall (subject, event)
- Fired on non-template-based domain (TemplateVM, StandaloneVM) when
- it first reports qrexec presence. This happens at the first
- domain startup just after its installation and is suitable for
- performing various post-installation setup.
- Handler for this event can be asynchronous (a coroutine).
- """
- #
- # per-class properties
- #
- #: directory in which domains of this class will reside
- dir_path_prefix = qubes.config.system_path['qubes_appvms_dir']
- #
- # properties loaded from XML
- #
- guivm = qubes.VMProperty('guivm', load_stage=4, allow_none=True,
- default=(lambda self: self.app.default_guivm),
- doc='VM used for Gui')
- audiovm = qubes.VMProperty('audiovm', load_stage=4, allow_none=True,
- default=(lambda self: self.app.default_audiovm),
- doc='VM used for Audio')
- virt_mode = qubes.property(
- 'virt_mode',
- type=str, setter=_setter_virt_mode,
- default=_default_virt_mode,
- doc="""Virtualisation mode: full virtualisation ("HVM"),
- or paravirtualisation ("PV"), or hybrid ("PVH").
- TemplateBasedVMs use its template\'s value by default.""")
- 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,
- setter=_setter_positive_int,
- default=_default_with_template(
- 'memory',
- lambda self:
- qubes.config.defaults[
- 'hvm_memory' if self.virt_mode == 'hvm' else 'memory']),
- doc='Memory currently available for this VM. TemplateBasedVMs use its '
- 'template\'s value by default.')
- maxmem = qubes.property(
- 'maxmem', type=int,
- setter=_setter_non_negative_int,
- default=_default_maxmem,
- doc="""Maximum amount of memory available for this VM (for the purpose
- of the memory balancer). Set to 0 to disable memory balancing for
- this qube. TemplateBasedVMs use its template\'s value by default
- (unless memory balancing not supported for this qube).""")
- stubdom_mem = qubes.property(
- 'stubdom_mem', type=int,
- setter=_setter_positive_int,
- default=None,
- doc='Memory amount allocated for the stubdom')
- vcpus = qubes.property(
- 'vcpus',
- type=int,
- setter=_setter_positive_int,
- default=_default_with_template('vcpus', 2),
- doc='Number of virtual CPUs for a qube. TemplateBasedVMs use its '
- 'template\'s value by default.')
- # CORE2: swallowed uses_default_kernel
- kernel = qubes.property(
- 'kernel', type=str,
- setter=_setter_kernel,
- default=_default_with_template('kernel',
- lambda self: self.app.default_kernel),
- doc='Kernel used by this domain. TemplateBasedVMs use its '
- 'template\'s value by default.')
- # CORE2: swallowed uses_default_kernelopts
- # pylint: disable=no-member
- kernelopts = qubes.property(
- 'kernelopts', type=str, load_stage=4,
- default=_default_kernelopts,
- doc='Kernel command line passed to domain. TemplateBasedVMs use its '
- 'template\'s value by default.')
- 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,
- # pylint: disable=no-member
- default=_default_with_template('default_user',
- 'user'),
- setter=_setter_default_user,
- doc='Default user to start applications as. TemplateBasedVMs use its '
- 'template\'s value by default.')
- qrexec_timeout = qubes.property(
- 'qrexec_timeout', type=int,
- default=_default_with_template(
- 'qrexec_timeout',
- lambda self: self.app.default_qrexec_timeout),
- setter=_setter_positive_int,
- doc="""Time in seconds after which qrexec connection attempt is deemed
- failed. Operating system inside VM should be able to boot in this
- time.""")
- shutdown_timeout = qubes.property(
- 'shutdown_timeout', type=int,
- default=_default_with_template(
- 'shutdown_timeout',
- lambda self: self.app.default_shutdown_timeout),
- setter=_setter_positive_int,
- doc="""Time in seconds for shutdown of the VM, after which VM may be
- forcefully powered off. Operating system inside VM should be
- able to fully shutdown 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.""")
- 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_timestamp = qubes.property(
- 'backup_timestamp', default=None,
- type=int,
- doc='Time of last backup of the qube, in seconds since unix epoch')
- default_dispvm = qubes.VMProperty(
- 'default_dispvm',
- load_stage=4,
- allow_none=True,
- default=(
- lambda self: self.app.default_dispvm),
- doc='Default VM to be used as Disposable VM for service calls.')
- management_dispvm = qubes.VMProperty(
- 'management_dispvm',
- load_stage=4,
- allow_none=True,
- default=_default_with_template(
- 'management_dispvm',
- (lambda self: self.app.management_dispvm)),
- doc='Default DVM template for Disposable VM for managing this VM.')
- updateable = qubes.property(
- 'updateable',
- default=(lambda self: not hasattr(self, 'template')),
- type=bool,
- setter=qubes.property.forbidden,
- doc='True if this machine may be updated on its own.')
- #
- # static, class-wide properties
- #
- #
- # properties not loaded from XML, calculated at run-time
- #
- def __str__(self):
- return self.name
- # VMM-related
- @qubes.stateless_property
- def xid(self):
- """Xen ID.
- Or not Xen, but ID.
- """
- if self.libvirt_domain is None:
- return -1
- try:
- if self.is_running():
- return self.libvirt_domain.ID()
- return -1
- except libvirt.libvirtError as e:
- if e.get_error_code() == libvirt.VIR_ERR_NO_DOMAIN:
- return -1
- self.log.exception('libvirt error code: {!r}'.format(
- e.get_error_code()))
- raise
- @qubes.stateless_property
- def stubdom_xid(self):
- if not self.is_running():
- return -1
- if self.app.vmm.xs is None:
- return -1
- stubdom_xid_str = self.app.vmm.xs.read(
- '', '/local/domain/{}/image/device-model-domid'.format(
- self.xid))
- if stubdom_xid_str is None or not stubdom_xid_str.isdigit():
- return -1
- return int(stubdom_xid_str)
- @property
- def attached_volumes(self):
- result = []
- xml_desc = self.libvirt_domain.XMLDesc()
- xml = lxml.etree.fromstring(xml_desc)
- for disk in xml.xpath("//domain/devices/disk"):
- if disk.find('backenddomain') is not None:
- pool_name = 'p_%s' % disk.find('backenddomain').get('name')
- pool = self.app.pools[pool_name]
- vid = disk.find('source').get('dev').split('/dev/')[1]
- for volume in pool.volumes:
- if volume.vid == vid:
- result += [volume]
- break
- return result + list(self.volumes.values())
- @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
- if self.app.vmm.offline_mode:
- return None
- # XXX _update_libvirt_domain?
- try:
- self._libvirt_domain = self.app.vmm.libvirt_conn.lookupByUUID(
- self.uuid.bytes)
- except libvirt.libvirtError as e:
- if e.get_error_code() == libvirt.VIR_ERR_NO_DOMAIN:
- self._update_libvirt_domain()
- else:
- raise
- return self._libvirt_domain
- @property
- def block_devices(self):
- """ Return all :py:class:`qubes.storage.BlockDevice` for current domain
- for serialization in the libvirt XML template as <disk>.
- """
- for v in self.volumes.values():
- block_dev = v.block_device()
- if block_dev is not None:
- yield block_dev
- @property
- def untrusted_qdb(self):
- """QubesDB handle for this domain."""
- if self._qdb_connection is None:
- if self.is_running():
- import qubesdb # pylint: disable=import-error
- self._qdb_connection = qubesdb.QubesDB(self.name)
- return self._qdb_connection
- @property
- def dir_path(self):
- """Root directory for files related to this domain"""
- return os.path.join(
- qubes.config.qubes_base_dir,
- self.dir_path_prefix,
- self.name)
- @property
- def icon_path(self):
- return os.path.join(self.dir_path, 'icon.png')
- @property
- def conf_file(self):
- return os.path.join(self.dir_path, 'libvirt.xml')
- # network-related
- #
- # constructor
- #
- def __init__(self, app, xml, volume_config=None, **kwargs):
- # migrate renamed properties
- if xml is not None:
- node_hvm = xml.find('./properties/property[@name=\'hvm\']')
- if node_hvm is not None:
- if qubes.property.bool(None, None, node_hvm.text):
- kwargs['virt_mode'] = 'hvm'
- else:
- kwargs['virt_mode'] = 'pv'
- node_hvm.getparent().remove(node_hvm)
- super(QubesVM, self).__init__(app, xml, **kwargs)
- if volume_config is None:
- volume_config = {}
- if hasattr(self, 'volume_config'):
- if xml is not None:
- for node in xml.xpath('volume-config/volume'):
- name = node.get('name')
- assert name
- for key, value in node.items():
- # pylint: disable=no-member
- if value == 'True':
- value = True
- try:
- self.volume_config[name][key] = value
- except KeyError:
- self.volume_config[name] = {key: value}
- for name, conf in volume_config.items():
- for key, value in conf.items():
- # pylint: disable=no-member
- try:
- self.volume_config[name][key] = value
- except KeyError:
- self.volume_config[name] = {key: value}
- elif volume_config:
- raise TypeError(
- 'volume_config specified, but {} did not expect that.'.format(
- self.__class__.__name__))
- # Init private attrs
- self._libvirt_domain = None
- self._qdb_connection = None
- # We assume a fully halted VM here. The 'domain-init' handler will
- # check if the VM is already running.
- self._domain_stopped_event_received = True
- self._domain_stopped_event_handled = True
- self._domain_stopped_future = None
- # Internal lock to ensure ordering between _domain_stopped_coro() and
- # start(). This should not be accessed anywhere else.
- self._domain_stopped_lock = asyncio.Lock()
- if xml is None:
- # we are creating new VM and attributes came through kwargs
- assert hasattr(self, 'qid')
- assert hasattr(self, 'name')
- if xml is None:
- # new qube, disable updates check if requested for new qubes
- # SEE: 1637 when features are done, migrate to plugin
- if not self.app.check_updates_vm:
- self.features['check-updates'] = False
- # will be initialized after loading all the properties
- #: operations which shouldn't happen simultaneously with qube startup
- # (including another startup of the same qube)
- self.startup_lock = asyncio.Lock()
- # fire hooks
- if xml is None:
- self.events_enabled = True
- self.fire_event('domain-init')
- def close(self):
- if self._qdb_connection is not None:
- self._qdb_connection.close()
- self._qdb_connection = None
- if self._libvirt_domain is not None:
- self._libvirt_domain = None
- super().close()
- def __hash__(self):
- return self.qid
- def __lt__(self, other):
- return self.name < other.name
- def __xml__(self):
- # pylint: disable=no-member
- element = super(QubesVM, self).__xml__()
- # pylint: enable=no-member
- if hasattr(self, 'volumes'):
- volume_config_node = lxml.etree.Element('volume-config')
- for volume in self.volumes.values():
- volume_config_node.append(volume.__xml__())
- element.append(volume_config_node)
- return element
- #
- # event handlers
- #
- @qubes.events.handler('domain-init', 'domain-load')
- def on_domain_init_loaded(self, event):
- # pylint: disable=unused-argument
- if not hasattr(self, 'uuid'):
- # pylint: disable=attribute-defined-outside-init
- self.uuid = uuid.uuid4()
- # Initialize VM image storage class;
- # it might be already initialized by a recursive call from a child VM
- if self.storage is None:
- self.storage = qubes.storage.Storage(self)
- if not self.app.vmm.offline_mode and self.is_running():
- self.start_qdb_watch()
- self._domain_stopped_event_received = False
- self._domain_stopped_event_handled = False
- @qubes.events.handler('property-set:label')
- def on_property_set_label(self, event, name, newvalue, oldvalue=None):
- # pylint: disable=unused-argument
- if self.icon_path:
- try:
- os.remove(self.icon_path)
- except OSError:
- pass
- if hasattr(os, "symlink"):
- os.symlink(newvalue.icon_path, self.icon_path)
- subprocess.call(['sudo', 'xdg-icon-resource', 'forceupdate'])
- else:
- shutil.copy(newvalue.icon_path, self.icon_path)
- @qubes.events.handler('property-pre-set:kernel')
- def on_property_pre_set_kernel(self, event, name, newvalue, oldvalue=None):
- # pylint: disable=unused-argument
- if not newvalue:
- return
- dirname = os.path.join(
- qubes.config.qubes_base_dir,
- qubes.config.system_path['qubes_kernels_base_dir'],
- newvalue)
- if not os.path.exists(dirname):
- raise qubes.exc.QubesPropertyValueError(
- self, self.property_get_def(name), newvalue,
- 'Kernel {!r} not installed'.format(
- newvalue))
- for filename in ('vmlinuz', 'initramfs'):
- if not os.path.exists(os.path.join(dirname, filename)):
- raise qubes.exc.QubesPropertyValueError(
- self, self.property_get_def(name), newvalue,
- 'Kernel {!r} not properly installed: '
- 'missing {!r} file'.format(
- newvalue, filename))
- @qubes.events.handler('property-pre-set:autostart')
- def on_property_pre_set_autostart(self, event, name, newvalue,
- oldvalue=None):
- # pylint: disable=unused-argument
- # workaround https://bugzilla.redhat.com/show_bug.cgi?id=1181922
- if newvalue:
- retcode = subprocess.call(
- ["sudo", "ln", "-sf",
- "/usr/lib/systemd/system/qubes-vm@.service",
- "/etc/systemd/system/multi-user.target.wants/qubes-vm@"
- "{}.service".format(self.name)])
- else:
- retcode = subprocess.call(
- ['sudo', 'systemctl', 'disable',
- 'qubes-vm@{}.service'.format(self.name)])
- if retcode:
- raise qubes.exc.QubesException(
- 'Failed to set autostart for VM in systemd')
- @qubes.events.handler('property-pre-del:autostart')
- def on_property_pre_del_autostart(self, event, name, oldvalue=None):
- # pylint: disable=unused-argument
- if oldvalue:
- retcode = subprocess.call(
- ['sudo', 'systemctl', 'disable',
- 'qubes-vm@{}.service'.format(self.name)])
- if retcode:
- raise qubes.exc.QubesException(
- 'Failed to reset autostart for VM in systemd')
- @qubes.events.handler('domain-remove-from-disk')
- def on_remove_from_disk(self, event, **kwargs):
- # pylint: disable=unused-argument
- if self.autostart:
- subprocess.call(
- ['sudo', 'systemctl', 'disable',
- 'qubes-vm@{}.service'.format(self.name)])
- @qubes.events.handler('domain-create-on-disk')
- def on_create_on_disk(self, event, **kwargs):
- # pylint: disable=unused-argument
- if self.autostart:
- subprocess.call(
- ['sudo', 'systemctl', 'enable',
- 'qubes-vm@{}.service'.format(self.name)])
- #
- # methods for changing domain state
- #
- @asyncio.coroutine
- def _ensure_shutdown_handled(self):
- """Make sure previous shutdown is fully handled.
- MUST NOT be called when domain is running.
- """
- with (yield from self._domain_stopped_lock):
- # Don't accept any new stopped event's till a new VM has been
- # created. If we didn't received any stopped event or it wasn't
- # handled yet we will handle this in the next lines.
- self._domain_stopped_event_received = True
- if self._domain_stopped_future is not None:
- # Libvirt stopped event was already received, so cancel the
- # future. If it didn't generate the Qubes events yet we
- # will do it below.
- self._domain_stopped_future.cancel()
- self._domain_stopped_future = None
- if not self._domain_stopped_event_handled:
- # No Qubes domain-stopped events have been generated yet.
- # So do this now.
- # Set this immediately such that we don't generate events
- # twice if an exception gets thrown.
- self._domain_stopped_event_handled = True
- yield from self.fire_event_async('domain-stopped')
- yield from self.fire_event_async('domain-shutdown')
- @asyncio.coroutine
- def start(self, start_guid=True, notify_function=None,
- mem_required=None):
- """Start domain
- :param bool start_guid: FIXME
- :param collections.Callable notify_function: FIXME
- :param int mem_required: FIXME
- """
- with (yield from self.startup_lock):
- # check if domain wasn't removed in the meantime
- if self not in self.app.domains:
- raise qubes.exc.QubesVMNotFoundError(self.name)
- # Intentionally not used is_running(): eliminate also "Paused",
- # "Crashed", "Halting"
- if self.get_power_state() != 'Halted':
- return self
- yield from self._ensure_shutdown_handled()
- self.log.info('Starting {}'.format(self.name))
- try:
- yield from self.fire_event_async('domain-pre-start',
- pre_event=True,
- start_guid=start_guid,
- mem_required=mem_required)
- except Exception as exc:
- self.log.error('Start failed: %s', str(exc))
- yield from self.fire_event_async('domain-start-failed',
- reason=str(exc))
- raise
- qmemman_client = None
- try:
- for devclass in self.devices:
- for dev in self.devices[devclass].persistent():
- if isinstance(dev, qubes.devices.UnknownDevice):
- raise qubes.exc.QubesException(
- '{} device {} not available'.format(
- devclass, dev))
- if self.virt_mode == 'pvh' and not self.kernel:
- raise qubes.exc.QubesException(
- 'virt_mode PVH require kernel to be set')
- yield from self.storage.verify()
- if self.netvm is not None:
- # pylint: disable = no-member
- if self.netvm.qid != 0:
- if not self.netvm.is_running():
- yield from self.netvm.start(
- start_guid=start_guid,
- notify_function=notify_function)
- qmemman_client = yield from asyncio.get_event_loop(). \
- run_in_executor(None, self.request_memory, mem_required)
- yield from self.storage.start()
- except Exception as exc:
- self.log.error('Start failed: %s', str(exc))
- # let anyone receiving domain-pre-start know that startup failed
- yield from self.fire_event_async('domain-start-failed',
- reason=str(exc))
- if qmemman_client:
- qmemman_client.close()
- raise
- try:
- self._update_libvirt_domain()
- self.libvirt_domain.createWithFlags(
- libvirt.VIR_DOMAIN_START_PAUSED)
- except libvirt.libvirtError as exc:
- # missing IOMMU?
- if self.virt_mode == 'hvm' and \
- list(self.devices['pci'].persistent()) and \
- not self.app.host.is_iommu_supported():
- exc = qubes.exc.QubesException(
- 'Failed to start an HVM qube with PCI devices assigned '
- '- hardware does not support IOMMU/VT-d/AMD-Vi')
- self.log.error('Start failed: %s', str(exc))
- yield from self.fire_event_async('domain-start-failed',
- reason=str(exc))
- yield from self.storage.stop()
- raise exc
- except Exception as exc:
- self.log.error('Start failed: %s', str(exc))
- # let anyone receiving domain-pre-start know that startup failed
- yield from self.fire_event_async('domain-start-failed',
- reason=str(exc))
- yield from self.storage.stop()
- raise
- finally:
- if qmemman_client:
- qmemman_client.close()
- self._domain_stopped_event_received = False
- self._domain_stopped_event_handled = False
- try:
- yield from self.fire_event_async('domain-spawn',
- start_guid=start_guid)
- self.log.info('Setting Qubes DB info for the VM')
- yield from self.start_qubesdb()
- self.create_qdb_entries()
- self.start_qdb_watch()
- self.log.warning('Activating the {} VM'.format(self.name))
- self.libvirt_domain.resume()
- yield from self.start_qrexec_daemon()
- yield from self.fire_event_async('domain-start',
- start_guid=start_guid)
- except Exception as exc: # pylint: disable=bare-except
- self.log.error('Start failed: %s', str(exc))
- # This avoids losing the exception if an exception is
- # raised in self._kill_locked(), because the vm is not
- # running or paused
- try:
- yield from self._kill_locked()
- except qubes.exc.QubesVMNotStartedError:
- pass
- # let anyone receiving domain-pre-start know that startup failed
- yield from self.fire_event_async('domain-start-failed',
- reason=str(exc))
- raise
- return self
- def on_libvirt_domain_stopped(self):
- """ Handle VIR_DOMAIN_EVENT_STOPPED events from libvirt.
- This is not a Qubes event handler. Instead we do some sanity checks
- and synchronization with start() and then emits Qubes events.
- """
- state = self.get_power_state()
- if state not in ['Halted', 'Crashed', 'Dying']:
- self.log.warning('Stopped event from libvirt received,'
- ' but domain is in state {}!'.format(state))
- # ignore this unexpected event
- return
- if self._domain_stopped_event_received:
- # ignore this event - already triggered by shutdown(), kill(),
- # or subsequent start()
- return
- self._domain_stopped_event_received = True
- self._domain_stopped_future = \
- asyncio.ensure_future(self._domain_stopped_coro())
- @asyncio.coroutine
- def _domain_stopped_coro(self):
- with (yield from self._domain_stopped_lock):
- assert not self._domain_stopped_event_handled
- # Set this immediately such that we don't generate events twice if
- # an exception gets thrown.
- self._domain_stopped_event_handled = True
- while self.get_power_state() == 'Dying':
- yield from asyncio.sleep(0.25)
- yield from self.fire_event_async('domain-stopped')
- yield from self.fire_event_async('domain-shutdown')
- @qubes.events.handler('domain-stopped')
- @asyncio.coroutine
- def on_domain_stopped(self, _event, **_kwargs):
- """Cleanup after domain was stopped"""
- try:
- yield from self.storage.stop()
- except qubes.storage.StoragePoolException:
- self.log.exception('Failed to stop storage for domain %s',
- self.name)
- @asyncio.coroutine
- def shutdown(self, force=False, wait=False, timeout=None):
- """Shutdown domain.
- :param force: ignored
- :param wait: wait for shutdown to complete
- :param timeout: shutdown wait timeout (for *wait*=True), defaults to
- :py:attr:`shutdown_timeout`
- :raises qubes.exc.QubesVMNotStartedError: \
- when domain is already shut down.
- """
- if self.is_halted():
- raise qubes.exc.QubesVMNotStartedError(self)
- try:
- yield from self.fire_event_async('domain-pre-shutdown',
- pre_event=True, force=force)
- self.libvirt_domain.shutdown()
- if wait:
- if timeout is None:
- timeout = self.shutdown_timeout
- while timeout > 0 and not self.is_halted():
- yield from asyncio.sleep(0.25)
- timeout -= 0.25
- with (yield from self.startup_lock):
- if self.is_halted():
- # make sure all shutdown tasks are completed
- yield from self._ensure_shutdown_handled()
- else:
- raise qubes.exc.QubesVMShutdownTimeoutError(self)
- except Exception as ex:
- yield from self.fire_event_async('domain-shutdown-failed',
- reason=str(ex))
- raise
- return self
- @asyncio.coroutine
- def kill(self):
- """Forcefully shutdown (destroy) domain.
- :raises qubes.exc.QubesVMNotStartedError: \
- when domain is already shut down.
- """
- if not self.is_running() and not self.is_paused():
- raise qubes.exc.QubesVMNotStartedError(self)
- with (yield from self.startup_lock):
- yield from self._kill_locked()
- return self
- @asyncio.coroutine
- def _kill_locked(self):
- """Forcefully shutdown (destroy) domain.
- This function needs to be called with self.startup_lock held."""
- try:
- self.libvirt_domain.destroy()
- except libvirt.libvirtError as e:
- if e.get_error_code() == libvirt.VIR_ERR_OPERATION_INVALID:
- raise qubes.exc.QubesVMNotStartedError(self)
- raise
- # make sure all shutdown tasks are completed
- yield from self._ensure_shutdown_handled()
- @asyncio.coroutine
- def suspend(self):
- """Suspend (pause) domain.
- :raises qubes.exc.QubesVMNotRunnignError: \
- when domain is already shut down.
- """
- if not self.is_running() and not self.is_paused():
- raise qubes.exc.QubesVMNotRunningError(self)
- if list(self.devices['pci'].attached()):
- if self.features.check_with_template('qrexec', False):
- yield from self.run_service_for_stdio('qubes.SuspendPre',
- user='root')
- self.libvirt_domain.pMSuspendForDuration(
- libvirt.VIR_NODE_SUSPEND_TARGET_MEM, 0, 0)
- else:
- self.libvirt_domain.suspend()
- return self
- @asyncio.coroutine
- def pause(self):
- """Pause (suspend) domain."""
- if not self.is_running():
- raise qubes.exc.QubesVMNotRunningError(self)
- self.libvirt_domain.suspend()
- return self
- @asyncio.coroutine
- def resume(self):
- """Resume suspended domain.
- :raises qubes.exc.QubesVMNotSuspendedError: when machine is not paused
- :raises qubes.exc.QubesVMError: when machine is suspended
- """
- # pylint: disable=not-an-iterable
- if self.get_power_state() == "Suspended":
- self.libvirt_domain.pMWakeup()
- if self.features.check_with_template('qrexec', False):
- yield from self.run_service_for_stdio('qubes.SuspendPost',
- user='root')
- else:
- yield from self.unpause()
- return self
- @asyncio.coroutine
- def unpause(self):
- """Resume (unpause) a domain"""
- if not self.is_paused():
- raise qubes.exc.QubesVMNotPausedError(self)
- self.libvirt_domain.resume()
- return self
- @asyncio.coroutine
- def run_service(self, service, source=None, user=None,
- filter_esc=False, autostart=False, gui=False, **kwargs):
- """Run service on this VM
- :param str service: service name
- :param qubes.vm.qubesvm.QubesVM source: source domain as presented to
- this VM
- :param str user: username to run service as
- :param bool filter_esc: filter escape sequences to protect terminal \
- emulator
- :param bool autostart: if :py:obj:`True`, machine will be started if \
- it is not running
- :param bool gui: when autostarting, also start gui daemon
- :rtype: asyncio.subprocess.Process
- .. note::
- User ``root`` is redefined to ``SYSTEM`` in the Windows agent code
- """
- # UNSUPPORTED from previous incarnation:
- # localcmd, wait, passio*, notify_function, `-e` switch
- #
- # - passio* and friends depend on params to command (like in stdlib)
- # - the filter_esc is orthogonal to passio*
- # - input: see run_service_for_stdio
- # - wait has no purpose since this is asynchronous
- # - notify_function is gone
- source = 'dom0' if source is None else self.app.domains[source].name
- if user is None:
- user = self.default_user
- if self.is_paused():
- # XXX what about autostart?
- raise qubes.exc.QubesVMNotRunningError(
- self, 'Domain {!r} is paused'.format(self.name))
- if not self.is_running():
- if not autostart:
- raise qubes.exc.QubesVMNotRunningError(self)
- yield from self.start(start_guid=gui)
- if not self.is_qrexec_running():
- raise qubes.exc.QubesVMError(
- self, 'Domain {!r}: qrexec not connected'.format(self.name))
- yield from self.fire_event_async('domain-cmd-pre-run', pre_event=True,
- start_guid=gui)
- return (yield from asyncio.create_subprocess_exec(
- qubes.config.system_path['qrexec_client_path'],
- '-d', str(self.name),
- *(('-t', '-T') if filter_esc else ()),
- '{}:QUBESRPC {} {}'.format(user, service, source),
- **kwargs))
- @asyncio.coroutine
- def run_service_for_stdio(self, *args, input=None, **kwargs):
- """Run a service, pass an optional input and return (stdout, stderr).
- Raises an exception if return code != 0.
- *args* and *kwargs* are passed verbatim to :py:meth:`run_service`.
- .. warning::
- There are some combinations if stdio-related *kwargs*, which are
- not filtered for problems originating between the keyboard and the
- chair.
- """ # pylint: disable=redefined-builtin
- kwargs.setdefault('stdin', subprocess.PIPE)
- kwargs.setdefault('stdout', subprocess.PIPE)
- kwargs.setdefault('stderr', subprocess.PIPE)
- p = yield from self.run_service(*args, **kwargs)
- # this one is actually a tuple, but there is no need to unpack it
- stdouterr = yield from p.communicate(input=input)
- if p.returncode:
- raise subprocess.CalledProcessError(p.returncode,
- args[0], *stdouterr)
- return stdouterr
- def run(self, command, user=None, **kwargs):
- """Run a shell command inside the domain using qrexec.
- This method is a coroutine.
- """ # pylint: disable=redefined-builtin
- if user is None:
- user = self.default_user
- return asyncio.create_subprocess_exec(
- qubes.config.system_path['qrexec_client_path'],
- '-d', str(self.name),
- '{}:{}'.format(user, command),
- **kwargs)
- @asyncio.coroutine
- def run_for_stdio(self, *args, input=None, **kwargs):
- """Run a shell command inside the domain using qrexec.
- This method is a coroutine.
- """ # pylint: disable=redefined-builtin
- kwargs.setdefault('stdin', subprocess.PIPE)
- kwargs.setdefault('stdout', subprocess.PIPE)
- kwargs.setdefault('stderr', subprocess.PIPE)
- p = yield from self.run(*args, **kwargs)
- stdouterr = yield from p.communicate(input=input)
- if p.returncode:
- raise subprocess.CalledProcessError(p.returncode,
- args[0], *stdouterr)
- return stdouterr
- def is_memory_balancing_possible(self):
- """Check if memory balancing can be enabled.
- Reasons to not enable it:
- - have PCI devices
- - balloon driver not present
- We don't have reliable way to detect the second point, but good
- heuristic is HVM virt_mode (PV and PVH require OS support and it does
- include balloon driver) and lack of qrexec/meminfo-writer service
- support (no qubes tools installed).
- """
- if list(self.devices['pci'].persistent()):
- return False
- if self.virt_mode == 'hvm':
- # if VM announce any supported service
- features_set = set(self.features)
- template = getattr(self, 'template', None)
- while template is not None:
- features_set.update(template.features)
- template = getattr(template, 'template', None)
- supported_services = any(f.startswith('supported-service.')
- for f in features_set)
- if (not self.features.check_with_template('qrexec', False) or
- (supported_services and
- not self.features.check_with_template(
- 'supported-service.meminfo-writer', False))):
- return False
- return True
- def request_memory(self, mem_required=None):
- if not qmemman_present:
- return None
- if mem_required is None:
- if self.virt_mode == 'hvm':
- if self.stubdom_mem:
- stubdom_mem = self.stubdom_mem
- else:
- if self.features.check_with_template('linux-stubdom', True):
- stubdom_mem = 128 # from libxl_create.c
- else:
- stubdom_mem = 28 # from libxl_create.c
- stubdom_mem += 16 # video ram
- else:
- stubdom_mem = 0
- initial_memory = self.memory
- mem_required = int(initial_memory + stubdom_mem) * 1024 * 1024
- qmemman_client = qubes.qmemman.client.QMemmanClient()
- try:
- mem_required_with_overhead = mem_required + MEM_OVERHEAD_BASE \
- + self.vcpus * MEM_OVERHEAD_PER_VCPU
- got_memory = qmemman_client.request_memory(
- mem_required_with_overhead)
- except IOError as e:
- raise IOError('Failed to connect to qmemman: {!s}'.format(e))
- if not got_memory:
- qmemman_client.close()
- raise qubes.exc.QubesMemoryError(self)
- return qmemman_client
- @staticmethod
- @asyncio.coroutine
- def start_daemon(*command, input=None, **kwargs):
- """Start a daemon for the VM
- This function take care to run it as appropriate user.
- :param command: command to run (array for
- :py:meth:`subprocess.check_call`)
- :param kwargs: args for :py:meth:`subprocess.check_call`
- :return: None
- """ # pylint: disable=redefined-builtin
- if os.getuid() == 0:
- # try to always have VM daemons running as normal user, otherwise
- # some files (like clipboard) may be created as root and cause
- # permission problems
- qubes_group = grp.getgrnam('qubes')
- command = ['runuser', '-u', qubes_group.gr_mem[0], '--'] + \
- list(command)
- p = yield from asyncio.create_subprocess_exec(*command, **kwargs)
- stdout, stderr = yield from p.communicate(input=input)
- if p.returncode:
- raise subprocess.CalledProcessError(p.returncode, command,
- output=stdout, stderr=stderr)
- @asyncio.coroutine
- 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()
- if not self.features.check_with_template('qrexec', False):
- self.log.debug(
- 'Starting the qrexec daemon in background, because of features')
- qrexec_env['QREXEC_STARTUP_NOWAIT'] = '1'
- else:
- qrexec_env['QREXEC_STARTUP_TIMEOUT'] = str(self.qrexec_timeout)
- try:
- yield from self.start_daemon(
- qubes.config.system_path['qrexec_daemon_path'], *qrexec_args,
- env=qrexec_env, stderr=subprocess.PIPE)
- except subprocess.CalledProcessError as err:
- if err.returncode == 3:
- raise qubes.exc.QubesVMError(
- self,
- 'Cannot connect to qrexec agent for {} seconds, '
- 'see /var/log/xen/console/guest-{}.log for details'.format(
- self.qrexec_timeout, self.name
- ))
- raise qubes.exc.QubesVMError(
- self, 'qrexec-daemon startup failed: ' + err.stderr.decode())
- @asyncio.coroutine
- def start_qubesdb(self):
- """Start QubesDB daemon.
- :raises OSError: when starting fails.
- """
- # drop old connection to QubesDB, if any
- self._qdb_connection = None
- self.log.info('Starting Qubes DB')
- try:
- yield from self.start_daemon(
- qubes.config.system_path['qubesdb_daemon_path'],
- str(self.xid),
- self.name)
- except subprocess.CalledProcessError:
- raise qubes.exc.QubesException('Cannot execute qubesdb-daemon')
- @asyncio.coroutine
- def create_on_disk(self, pool=None, pools=None):
- """Create files needed for VM.
- """
- self.log.info('Creating directory: {0}'.format(self.dir_path))
- os.makedirs(self.dir_path, mode=0o775, exist_ok=True)
- if pool or pools:
- # pylint: disable=attribute-defined-outside-init
- self.volume_config = _patch_volume_config(self.volume_config, pool,
- pools)
- self.storage = qubes.storage.Storage(self)
- try:
- yield from self.storage.create()
- except:
- try:
- yield from self.storage.remove()
- os.rmdir(self.dir_path)
- except: # pylint: disable=bare-except
- self.log.exception('failed to cleanup {} after failed VM '
- 'creation'.format(self.dir_path))
- raise
- if os.path.exists(self.icon_path):
- os.unlink(self.icon_path)
- 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
- yield from self.fire_event_async('domain-create-on-disk')
- @asyncio.coroutine
- def remove_from_disk(self):
- """Remove domain remnants from disk."""
- if not self.is_halted():
- raise qubes.exc.QubesVMNotHaltedError(
- "Can't remove VM {!s}, because it's in state {!r}.".format(
- self, self.get_power_state()))
- # make sure shutdown is handled before removing anything, but only if
- # handling is pending; if not, we may be called from within
- # domain-shutdown event (DispVM._auto_cleanup), which would deadlock
- if not self._domain_stopped_event_handled:
- yield from self._ensure_shutdown_handled()
- yield from self.fire_event_async('domain-remove-from-disk')
- try:
- yield from self.storage.remove()
- finally:
- try:
- # TODO: make it async?
- shutil.rmtree(self.dir_path)
- except FileNotFoundError:
- pass
- @asyncio.coroutine
- def clone_disk_files(self, src, pool=None, pools=None, ):
- """Clone files from other vm.
- :param qubes.vm.qubesvm.QubesVM src: source VM
- """
- # If the current vm name is not a part of `self.app.domains.keys()`,
- # then the current vm is in creation process. Calling
- # `self.is_halted()` at this point, would instantiate libvirt, we want
- # avoid that.
- if self.name in self.app.domains.keys() and not self.is_halted():
- raise qubes.exc.QubesVMNotHaltedError(
- self, 'Cannot clone a running domain {!r}'.format(self.name))
- msg = "Destination {!s} already exists".format(self.dir_path)
- assert not os.path.exists(self.dir_path), msg
- self.log.info('Creating directory: {0}'.format(self.dir_path))
- os.makedirs(self.dir_path, mode=0o775, exist_ok=True)
- if pool or pools:
- # pylint: disable=attribute-defined-outside-init
- self.volume_config = _patch_volume_config(self.volume_config, pool,
- pools)
- self.storage = qubes.storage.Storage(self)
- yield from self.storage.clone(src)
- self.storage.verify()
- assert self.volumes != {}
- if src.icon_path is not None \
- and os.path.exists(src.icon_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
- yield from self.fire_event_async('domain-clone-files', src=src)
- #
- # 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.
- ``'Suspended'`` Machine is S3-suspended.
- ``'Halting'`` Machine is in process of shutting down.
- ``'Dying'`` Machine is still in process of shutting down.
- ``'Crashed'`` Machine crashed and is unusable, probably because of
- bug in dom0.
- ``'NA'`` Machine is in unknown state (most likely libvirt domain
- is undefined).
- =============== ========================================================
- 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="kill()"
- URL="#qubes.vm.qubesvm.QubesVM.kill"
- 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="suspend()" URL="#qubes.vm.qubesvm.QubesVM.suspend"
- color=gray50 fontcolor=gray50];
- Paused -> Running
- [label="unpause()" URL="#qubes.vm.qubesvm.QubesVM.unpause"
- color=gray75 fontcolor=gray75];
- Suspended -> Running
- [label="resume()" URL="#qubes.vm.qubesvm.QubesVM.resume"
- 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's enum describing precise state of a domain.
- """ # pylint: disable=too-many-return-statements
- # don't try to define libvirt domain, if it isn't there, VM surely
- # isn't running
- # reason for this "if": allow vm.is_running() in PCI (or other
- # device) extension while constructing libvirt XML
- if self.app.vmm.offline_mode:
- return 'Halted'
- if self._libvirt_domain is None:
- try:
- self._libvirt_domain = self.app.vmm.libvirt_conn.lookupByUUID(
- self.uuid.bytes)
- except libvirt.libvirtError as e:
- if e.get_error_code() == libvirt.VIR_ERR_NO_DOMAIN:
- return 'Halted'
- raise
- libvirt_domain = self.libvirt_domain
- if libvirt_domain is None:
- return 'Halted'
- try:
- if libvirt_domain.isActive():
- # pylint: disable=line-too-long
- if libvirt_domain.state()[0] == libvirt.VIR_DOMAIN_PAUSED:
- return "Paused"
- if libvirt_domain.state()[0] == libvirt.VIR_DOMAIN_CRASHED:
- return "Crashed"
- if libvirt_domain.state()[0] == libvirt.VIR_DOMAIN_SHUTDOWN:
- return "Halting"
- if libvirt_domain.state()[0] == libvirt.VIR_DOMAIN_SHUTOFF:
- return "Dying"
- if libvirt_domain.state()[
- 0] == libvirt.VIR_DOMAIN_PMSUSPENDED: # nopep8
- return "Suspended"
- if not self.is_fully_usable():
- return "Transient"
- return "Running"
- return 'Halted'
- except libvirt.libvirtError as e:
- if e.get_error_code() == libvirt.VIR_ERR_NO_DOMAIN:
- return 'Halted'
- raise
- assert False
- def is_halted(self):
- """ Check whether this domain's state is 'Halted'
- :returns: :py:obj:`True` if this domain is halted, \
- :py:obj:`False` otherwise.
- :rtype: bool
- """
- return self.get_power_state() == 'Halted'
- 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
- """
- if self.app.vmm.offline_mode:
- return False
- # don't try to define libvirt domain, if it isn't there, VM surely
- # isn't running
- # reason for this "if": allow vm.is_running() in PCI (or other
- # device) extension while constructing libvirt XML
- if self._libvirt_domain is None:
- try:
- self._libvirt_domain = self.app.vmm.libvirt_conn.lookupByUUID(
- self.uuid.bytes)
- except libvirt.libvirtError as e:
- if e.get_error_code() == libvirt.VIR_ERR_NO_DOMAIN:
- return False
- raise
- return bool(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()[0] == libvirt.VIR_DOMAIN_PAUSED
- 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: # pylint: disable=comparison-with-callable
- return False
- return os.path.exists('/var/run/qubes/qrexec.%s' % self.name)
- def is_fully_usable(self):
- return all(self.fire_event('domain-is-fully-usable'))
- @qubes.events.handler('domain-is-fully-usable')
- def on_domain_is_fully_usable(self, event):
- """Check whether domain is running and sane.
- Currently this checks for running qrexec.
- """ # pylint: disable=unused-argument
- # Running gui-daemon implies also VM running
- if not self.is_qrexec_running():
- yield False
- # 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
- try:
- if not self.libvirt_domain.isActive():
- return 0
- return self.libvirt_domain.info()[1]
- except libvirt.libvirtError as e:
- if e.get_error_code() in (
- # qube no longer exists
- libvirt.VIR_ERR_NO_DOMAIN,
- # libxl_domain_info failed (race condition from isActive)
- libvirt.VIR_ERR_INTERNAL_ERROR):
- return 0
- self.log.exception(
- 'libvirt error code: {!r}'.format(e.get_error_code()))
- raise
- 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
- try:
- return self.libvirt_domain.maxMemory()
- except libvirt.libvirtError as e:
- if e.get_error_code() in (
- # qube no longer exists
- libvirt.VIR_ERR_NO_DOMAIN,
- # libxl_domain_info failed (race condition from isActive)
- libvirt.VIR_ERR_INTERNAL_ERROR):
- return 0
- self.log.exception(
- 'libvirt error code: {!r}'.format(e.get_error_code()))
- raise
- def get_cputime(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 self.libvirt_domain is None:
- return 0
- if not self.libvirt_domain.isActive():
- return 0
- try:
- if not self.libvirt_domain.isActive():
- return 0
- # this does not work, because libvirt
- # return self.libvirt_domain.getCPUStats(
- # libvirt.VIR_NODE_CPU_STATS_ALL_CPUS, 0)[0]['cpu_time']/10**9
- return self.libvirt_domain.info()[4]
- except libvirt.libvirtError as e:
- if e.get_error_code() in (
- # qube no longer exists
- libvirt.VIR_ERR_NO_DOMAIN,
- # libxl_domain_info failed (race condition from isActive)
- libvirt.VIR_ERR_INTERNAL_ERROR):
- return 0
- self.log.exception(
- 'libvirt error code: {!r}'.format(e.get_error_code()))
- raise
- # miscellanous
- @qubes.stateless_property
- def start_time(self):
- """Tell when machine was started.
- :rtype: float or None
- """
- 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 float(start_time)
- return None
- @property
- def kernelopts_common(self):
- """Kernel options which should be used in addition to *kernelopts*
- property.
- This is specific to kernel (and initrd if any)
- """
- if not self.kernel:
- return ''
- kernels_dir = self.storage.kernels_dir
- kernelopts_path = os.path.join(kernels_dir,
- 'default-kernelopts-common.txt')
- if os.path.exists(kernelopts_path):
- with open(kernelopts_path) as f_kernelopts:
- return f_kernelopts.read().rstrip('\n\r')
- else:
- return qubes.config.defaults['kernelopts_common']
- #
- # 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)
- def create_qdb_entries(self):
- """Create entries in Qubes DB.
- """
- # pylint: disable=no-member
- self.untrusted_qdb.write('/name', self.name)
- self.untrusted_qdb.write('/type', self.__class__.__name__)
- self.untrusted_qdb.write('/default-user', self.default_user)
- self.untrusted_qdb.write('/qubes-vm-updateable', str(self.updateable))
- self.untrusted_qdb.write('/qubes-vm-persistence',
- 'full' if self.updateable else 'rw-only')
- self.untrusted_qdb.write('/qubes-debug-mode', str(int(self.debug)))
- try:
- self.untrusted_qdb.write('/qubes-base-template', self.template.name)
- except AttributeError:
- self.untrusted_qdb.write('/qubes-base-template', '')
- self.untrusted_qdb.write('/qubes-random-seed',
- base64.b64encode(qubes.utils.urandom(64)))
- if self.provides_network:
- # '/qubes-netvm-network' value is only checked for being non empty
- self.untrusted_qdb.write('/qubes-netvm-network', str(self.gateway))
- self.untrusted_qdb.write('/qubes-netvm-gateway', str(self.gateway))
- if self.gateway6: # pylint: disable=using-constant-test
- self.untrusted_qdb.write('/qubes-netvm-gateway6',
- str(self.gateway6))
- self.untrusted_qdb.write('/qubes-netvm-netmask', str(self.netmask))
- for i, addr in zip(('primary', 'secondary'), self.dns):
- self.untrusted_qdb.write('/qubes-netvm-{}-dns'.format(i), addr)
- if self.netvm is not None:
- self.untrusted_qdb.write('/qubes-mac', str(self.mac))
- self.untrusted_qdb.write('/qubes-ip', str(self.visible_ip))
- self.untrusted_qdb.write('/qubes-netmask',
- str(self.visible_netmask))
- self.untrusted_qdb.write('/qubes-gateway',
- str(self.visible_gateway))
- for i, addr in zip(('primary', 'secondary'), self.dns):
- self.untrusted_qdb.write('/qubes-{}-dns'.format(i), str(addr))
- if self.visible_ip6: # pylint: disable=using-constant-test
- self.untrusted_qdb.write('/qubes-ip6', str(self.visible_ip6))
- if self.visible_gateway6: # pylint: disable=using-constant-test
- self.untrusted_qdb.write('/qubes-gateway6',
- str(self.visible_gateway6))
- tzname = qubes.utils.get_timezone()
- if tzname:
- self.untrusted_qdb.write('/qubes-timezone', tzname)
- self.untrusted_qdb.write('/qubes-block-devices', '')
- self.untrusted_qdb.write('/qubes-usb-devices', '')
- # TODO: Currently the whole qmemman is quite Xen-specific, so stay with
- # xenstore for it until decided otherwise
- if qmemman_present:
- self.app.vmm.xs.set_permissions('',
- '/local/domain/{}/memory'.format(
- self.xid),
- [{'dom': self.xid}])
- self.fire_event('domain-qdb-create')
- # TODO async; update this in constructor
- def _update_libvirt_domain(self):
- """Re-initialise :py:attr:`libvirt_domain`."""
- domain_config = self.create_config_file()
- try:
- self._libvirt_domain = self.app.vmm.libvirt_conn.defineXML(
- domain_config)
- except libvirt.libvirtError as e:
- if e.get_error_code() == libvirt.VIR_ERR_OS_TYPE \
- and e.get_str2() == 'hvm':
- raise qubes.exc.QubesVMError(
- self,
- 'HVM qubes are not supported on this machine. '
- 'Check BIOS settings for VT-x/AMD-V extensions.')
- raise
- #
- # workshop -- those are to be reworked later
- #
- def get_prefmem(self):
- # TODO: qmemman is still xen specific
- untrusted_meminfo_key = self.app.vmm.xs.read(
- '', '/local/domain/{}/memory/meminfo'.format(self.xid))
- if untrusted_meminfo_key is None or untrusted_meminfo_key == '':
- return 0
- domain = qubes.qmemman.DomainState(self.xid)
- qubes.qmemman.algo.refresh_meminfo_for_domain(
- domain, untrusted_meminfo_key)
- if domain.mem_used is None:
- # apparently invalid xenstore content
- return 0
- domain.memory_maximum = self.get_mem_static_max() * 1024
- return qubes.qmemman.algo.prefmem(domain) / 1024
- def _clean_volume_config(config):
- common_attributes = ['name', 'pool', 'size',
- 'revisions_to_keep', 'rw', 'snap_on_start',
- 'save_on_stop', 'source']
- return {k: v for k, v in config.items() if k in common_attributes}
- def _patch_pool_config(config, pool=None, pools=None):
- assert pool is not None or pools is not None
- is_snapshot = config['snap_on_start']
- is_rw = config['rw']
- name = config['name']
- if pool and not is_snapshot and is_rw:
- config['pool'] = str(pool)
- elif pool:
- pass
- elif pools and name in pools.keys():
- if not is_snapshot:
- config['pool'] = str(pools[name])
- else:
- msg = "Snapshot volume {0!s} must be in the same pool as its " \
- "origin ({0!s} volume of template)," \
- "cannot move to pool {1!s} " \
- .format(name, pools[name])
- raise qubes.exc.QubesException(msg)
- return config
- def _patch_volume_config(volume_config, pool=None, pools=None):
- assert not (pool and pools), \
- 'You can not pass pool & pools parameter at same time'
- assert pool or pools
- result = {}
- for name, config in volume_config.items():
- # copy only the subset of volume_config key/values
- dst_config = _clean_volume_config(config)
- if pool is not None or pools is not None:
- dst_config = _patch_pool_config(dst_config, pool, pools)
- result[name] = dst_config
- return result
|