feat(lxd): add s390x virtio-ports detection for LXD

Support LXD detection on IBM's s390x architecture using virtio-ports
serial device detection. Add a new detection method that checks for
LXD serial devices in /sys/class/virtio-ports/ for both current
(com.canonical.lxd) and legacy (org.linuxcontainers.lxd) names.
Update public LXD datasource documentation for this detection method.

Drop the now unnecessary DMI board name check from ds-identify and
DataSourceLXD because virtio-ports is sufficient in bot KVM/QEMU and
s390x.

The following mechinisms for LXD detection are retained:
1. /dev/lxd/sock socket file (primary method)
2. virtio-ports serial device (KVM/QEMU and new for s390x)

Implements: PL073

Author: blackboxsw

cloudinit/sources/DataSourceLXD.py

@@ -196,13 +196,30 @@ def _unpickle(self, ci_pkl_version: int) -> None:
     @staticmethod
     def ds_detect() -> bool:
         """Check platform environment to report if this datasource may run."""
-        if not os.path.exists(LXD_SOCKET_PATH):
-            LOG.warning("%s does not exist.", LXD_SOCKET_PATH)
-            return False
-        elif not stat.S_ISSOCK(os.lstat(LXD_SOCKET_PATH).st_mode):
+        if os.path.exists(LXD_SOCKET_PATH):
+            if stat.S_ISSOCK(os.lstat(LXD_SOCKET_PATH).st_mode):
+                return True
             LOG.warning("%s is not a socket", LXD_SOCKET_PATH)
-            return False
-        return True
+
+        # On LXD KVM instances (particularly s390x), /dev/lxd/sock may not
+        # be available yet. Check for LXD virtio serial device presence
+        # in virtio-ports.
+        virtio_ports_path = "/sys/class/virtio-ports"
+        if os.path.isdir(virtio_ports_path):
+            try:
+                for port in os.listdir(virtio_ports_path):
+                    name_file = os.path.join(virtio_ports_path, port, "name")
+                    if os.path.isfile(name_file):
+                        # Check for both current and legacy LXD serial names
+                        if util.load_text_file(name_file).strip() in (
+                            "com.canonical.lxd",
+                            "org.linuxcontainers.lxd",
+                        ):
+                            return True
+            except (OSError, IOError) as e:
+                LOG.warning("Cannot check virtio-ports: %s", e)
+
+        return False
 
     def _get_data(self) -> bool:
         """Crawl LXD socket API instance data and return True on success"""

doc/rtd/reference/datasources/lxd.rst

@@ -7,25 +7,25 @@ The LXD datasource allows the user to provide custom user-data,
 vendor-data, meta-data and network-config to the instance without running
 a network service (or even without having a network at all). This datasource
 performs HTTP GETs against the `LXD socket device`_ which is provided to each
-running LXD container and VM as ``/dev/lxd/sock`` and represents all
+running LXD container and VM as :file:`/dev/lxd/sock` and represents all
 instance-meta-data as versioned HTTP routes such as:
 
   - 1.0/meta-data
   - 1.0/config/cloud-init.vendor-data
   - 1.0/config/cloud-init.user-data
   - 1.0/config/user.<any-custom-key>
 
-The LXD socket device ``/dev/lxd/sock`` is only present on containers and VMs
-when the instance configuration has ``security.devlxd=true`` (default).
+The LXD socket device :file:`/dev/lxd/sock` is only present on containers and
+VMs when the instance configuration has ``security.devlxd=true`` (default).
 Disabling the ``security.devlxd`` configuration setting at initial launch will
 ensure that ``cloud-init`` uses the :ref:`datasource_nocloud` datasource.
 Disabling ``security.devlxd`` over the life of the container will result in
 warnings from ``cloud-init``, and ``cloud-init`` will keep the
 originally-detected LXD datasource.
 
 The LXD datasource is detected as viable by ``ds-identify`` during the
-:ref:`detect stage<boot-Detect>` when either ``/dev/lxd/sock`` exists or
-``/sys/class/dmi/id/board_name`` matches "LXD".
+:ref:`detect stage<boot-Detect>` when either :file:`/dev/lxd/sock` exists
+or an LXD serial device is present in :file:`/sys/class/virtio-ports`.
 
 The LXD datasource provides ``cloud-init`` with the ability to react to
 meta-data, vendor-data, user-data and network-config changes, and to render the

tests/integration_tests/datasources/test_lxd_discovery.py

@@ -3,6 +3,7 @@
 import pytest
 import yaml
 
+from tests.integration_tests.clouds import IntegrationCloud
 from tests.integration_tests.instances import IntegrationInstance
 from tests.integration_tests.integration_settings import PLATFORM
 from tests.integration_tests.releases import CURRENT_RELEASE, IS_UBUNTU
@@ -20,14 +21,17 @@ def _customize_environment(client: IntegrationInstance):
 
     if client.settings.PLATFORM == "lxd_vm":
         # ds-identify runs at systemd generator time before /dev/lxd/sock.
-        # Assert we can expected artifact which indicates LXD is viable.
-        result = client.execute("cat /sys/class/dmi/id/board_name")
+        # Assert we can expected virtio-ports artifacts which indicates LXD is
+        # viable.
+        result = client.execute("cat /sys/class/virtio-ports/*/name")
         if not result.ok:
             raise AssertionError(
-                "Missing expected /sys/class/dmi/id/board_name"
+                "Missing expected /sys/class/virtio-ports/*/name"
             )
         if "LXD" != result.stdout:
-            raise AssertionError(f"DMI board_name is not LXD: {result.stdout}")
+            raise AssertionError(
+                f"virtio-ports not LXD serial devices: {result.stdout}"
+            )
 
     # Having multiple datasources prevents ds-identify from short-circuiting
     # detection logic with a log like:
@@ -53,7 +57,34 @@ def _customize_environment(client: IntegrationInstance):
     client.restart()
 
 
-@pytest.mark.skipif(not IS_UBUNTU, reason="Netplan usage")
+@pytest.mark.skipif(PLATFORM != "lxd_vm", reason="Test is LXD KVM specific")
+def test_lxd_kvm_datasource_discovery_without_lxd_socket(
+    session_cloud: IntegrationCloud,
+):
+    """Test DataSourceLXD is detected on KVM by virtio-ports."""
+    with session_cloud.launch(
+        wait=False,  # to prevent cloud-init status --wait
+        launch_kwargs={
+            # We detect the LXD datasource using a socket available to the
+            # container. This prevents the socket from being exposed in the
+            # container, so LXD will not be detected.
+            # This allows us to wait for detection in 'init' stage with
+            # DataSourceNoCloudNet.
+            "config_dict": {"security.devlxd": False},
+        },
+    ) as client:
+        _customize_environment(client)
+        # We know this will be an LXD instance due to our pytest mark
+        client.instance.execute_via_ssh = False  # pyright: ignore
+        result = wait_for_cloud_init(client, num_retries=60)
+        if not result.ok:
+            raise AssertionError("cloud-init failed:\n%s", result.stderr)
+        if "DataSourceLXD" not in result.stdout:
+            raise AssertionError(
+                "cloud-init did not discover DataSourceLXD", result.stdout
+            )
+
+
 @pytest.mark.skipif(
     PLATFORM not in ["lxd_container", "lxd_vm"],
     reason="Test is LXD specific",

tests/unittests/sources/test_lxd.py

@@ -2,6 +2,7 @@
 
 import copy
 import json
+import logging
 import re
 import stat
 from collections import namedtuple
@@ -15,6 +16,8 @@
 from cloudinit.sources import DataSourceLXD as lxd
 from cloudinit.sources import InvalidMetaDataException
 from cloudinit.sources.DataSourceLXD import MetaDataKeys
+from cloudinit.util import ensure_file
+from tests.unittests.helpers import populate_dir
 
 DS_PATH = "cloudinit.sources.DataSourceLXD."
 
@@ -356,28 +359,83 @@ def test_network_config_crawled_metadata_no_network_config(
 
 class TestIsPlatformViable:
     @pytest.mark.parametrize(
-        "exists,lstat_mode,expected",
+        "exists,lstat_mode,virtio_ports,expected",
         (
-            (False, None, False),
-            (True, stat.S_IFREG, False),
-            (True, stat.S_IFSOCK, True),
+            pytest.param(
+                False,
+                None,
+                {},
+                False,
+                id="not_viable_no_lxd_sock_path_no_virtio",
+            ),
+            pytest.param(
+                True,
+                stat.S_IFREG,
+                {},
+                False,
+                id="not_viable_lxd_sock_path_regular_file_no_virtio",
+            ),
+            pytest.param(
+                True,
+                stat.S_IFSOCK,
+                {},
+                True,
+                id="viable_when_lxd_sock_is_socket_file_no_virtio",
+            ),
+            pytest.param(
+                False,
+                None,
+                {"vport5p1/name": "com.redhat.spice.0"},
+                False,
+                id="not_viable_no_lxd_sock_with_non_lxd_virtio",
+            ),
+            pytest.param(
+                False,
+                None,
+                {
+                    "vport5p1/name": "com.redhat.spice.0",
+                    "vport5p2/name": "org.linuxcontainers.lxd",
+                },
+                True,
+                id="viable_no_lxd_sock_with_legacy_lxd_virtio",
+            ),
+            pytest.param(
+                False,
+                None,
+                {
+                    "vport5p1/name": "com.redhat.spice.0",
+                    "vport5p2/name": "com.canonical.lxd",
+                },
+                True,
+                id="viable_no_lxd_sock_with_canonical_lxd_virtio",
+            ),
         ),
     )
     @mock.patch(DS_PATH + "os.lstat")
-    @mock.patch(DS_PATH + "os.path.exists")
+    @pytest.mark.usefixtures("fake_filesystem")
     def test_expected_viable(
-        self, m_exists, m_lstat, exists, lstat_mode, expected
+        self, m_lstat, exists, lstat_mode, virtio_ports, expected
     ):
         """Return True only when LXD_SOCKET_PATH exists and is a socket."""
-        m_exists.return_value = exists
+        if virtio_ports:
+            populate_dir("/sys/class/virtio-ports", virtio_ports)
+        if exists:
+            ensure_file(lxd.LXD_SOCKET_PATH)
         m_lstat.return_value = LStatResponse(lstat_mode)
         assert expected is lxd.DataSourceLXD.ds_detect()
-        m_exists.assert_has_calls([mock.call(lxd.LXD_SOCKET_PATH)])
         if exists:
             m_lstat.assert_has_calls([mock.call(lxd.LXD_SOCKET_PATH)])
         else:
             assert 0 == m_lstat.call_count
 
+    @pytest.mark.usefixtures("fake_filesystem")
+    @mock.patch(DS_PATH + "util.load_text_file", side_effect=OSError("Oh-no"))
+    def test_warn_on_oserror(self, m_load_text_file, caplog):
+        populate_dir("/sys/class/virtio-ports", {"vport5p1/name": "something"})
+        with caplog.at_level(logging.WARNING):
+            assert False is lxd.DataSourceLXD.ds_detect()
+        assert "Cannot check virtio-ports: Oh-no" in caplog.messages
+
 
 class TestReadMetadata:
     @pytest.mark.parametrize(