q-dev: backend_name

Author: piotrbartman

qubes/api/admin.py

@@ -1321,12 +1321,15 @@ async def vm_device_assign(self, endpoint, untrusted_payload):
         await self.dest.devices[devclass].assign(assignment)
         self.app.save()
 
-    def load_device_info(self, devclass) -> DeviceInfo:
+    def load_device_info(self, devclass) -> VirtualDevice:
         # qrexec already verified that no strange characters are in self.arg
         _dev = VirtualDevice.from_qarg(self.arg, devclass, self.app.domains)
         # load all info, may raise KeyError, either on domain or port_id
-        return self.app.domains[
-            _dev.backend_domain].devices[devclass][_dev.port_id]
+        try:
+            return self.app.domains[
+                _dev.backend_domain].devices[devclass][_dev.port_id]
+        except KeyError:
+            return _dev
 
     # Assign/Unassign action can modify only persistent state of running VM.
     # For this reason, write=True

qubes/device_protocol.py

@@ -238,29 +238,35 @@ def __init__(self, backend_domain, port_id, devclass):
         self.__devclass = devclass
 
     def __hash__(self):
-        return hash((self.backend_domain.name, self.port_id, self.devclass))
+        return hash((self.backend_name, self.port_id, self.devclass))
 
     def __eq__(self, other):
         if isinstance(other, Port):
             return (
-                self.backend_domain == other.backend_domain and
-                self.port_id == other.port_id and
-                self.devclass == other.devclass
+                    self.backend_name == other.backend_name and
+                    self.port_id == other.port_id and
+                    self.devclass == other.devclass
             )
         return False
 
     def __lt__(self, other):
         if isinstance(other, Port):
-            return (self.backend_domain.name, self.devclass, self.port_id) < \
-                   (other.backend_domain.name, other.devclass, other.port_id)
+            return (self.backend_name, self.devclass, self.port_id) < \
+                   (self.backend_name, other.devclass, other.port_id)
         raise TypeError(f"Comparing instances of 'Port' and '{type(other)}' "
                         "is not supported")
 
     def __repr__(self):
-        return f"{self.backend_domain.name}+{self.port_id}"
+        return f"{self.backend_name}+{self.port_id}"
 
     def __str__(self):
-        return f"{self.backend_domain.name}:{self.port_id}"
+        return f"{self.backend_name}:{self.port_id}"
+
+    @property
+    def backend_name(self) -> str:
+        if self.backend_domain is not None:
+            return self.backend_domain.name
+        return "*"
 
     @classmethod
     def from_qarg(
@@ -304,7 +310,7 @@ def port_id(self) -> str:
         return self.__port_id
 
     @property
-    def backend_domain(self) -> QubesVM:
+    def backend_domain(self) -> Optional[QubesVM]:
         """ Which domain exposed this port. (immutable)"""
         return self.__backend_domain
 
@@ -367,6 +373,13 @@ def backend_domain(self):
             return self.port.backend_domain
         return '*'
 
+    @property
+    def backend_name(self):
+        if self.port != '*':
+            return self.port.backend_name
+        return '*'
+
+
     @property
     def port_id(self):
         if self.port != '*' and self.port.port_id is not None:
@@ -478,7 +491,8 @@ def _parse(
     ) -> 'VirtualDevice':
         if backend is None:
             backend_name, identity = representation.split(sep, 1)
-            backend = get_domain(backend_name)
+            if backend_name != '*':
+                backend = get_domain(backend_name)
         else:
             identity = representation
         port_id, _, devid = identity.partition(':')
@@ -1070,15 +1084,19 @@ def __lt__(self, other):
 
     @property
     def backend_domain(self):
-        return self.virtual_device.port.backend_domain
+        return self.virtual_device.backend_domain
+
+    @property
+    def backend_name(self) -> str:
+        return self.virtual_device.backend_name
 
     @property
     def port_id(self):
-        return self.virtual_device.port.port_id
+        return self.virtual_device.port_id
 
     @property
     def devclass(self):
-        return self.virtual_device.port.devclass
+        return self.virtual_device.devclass
 
     @property
     def device_id(self):

qubes/vm/__init__.py

@@ -310,11 +310,13 @@ def load_extras(self):
                         del options['identity']
                     else:
                         identity = node.get('identity', '*')
+                    backend_name = node.get('backend-domain', None)
+                    backend = self.app.domains[backend_name] \
+                        if backend_name else None
                     device_assignment = qubes.device_protocol.DeviceAssignment(
                         qubes.device_protocol.VirtualDevice(
                             qubes.device_protocol.Port(
-                                backend_domain=self.app.domains[
-                                    node.get('backend-domain')],
+                                backend_domain=backend,
                                 port_id=node.get('id', '*'),
                                 devclass=devclass,
                             ),
@@ -377,7 +379,7 @@ def __xml__(self):
             devices.set('class', devclass)
             for assignment in self.devices[devclass].get_assigned_devices():
                 node = lxml.etree.Element('device')
-                node.set('backend-domain', assignment.backend_domain.name)
+                node.set('backend-domain', str(assignment.backend_name))
                 node.set('id', assignment.port_id)
                 node.set('mode', assignment.mode.value)
                 identity = assignment.device_id or '*'