labgrid-boardkit 0.1.0__py3-none-any.whl

labgrid_boardkit/strategies/fastboot.py

@@ -0,0 +1,141 @@
+import enum
+import subprocess
+import time
+from pathlib import Path
+
+import attr
+from labgrid.strategy.common import StrategyError
+from labgrid.util.managedfile import ManagedFile
+
+from labgrid_boardkit.strategies.base import BoardStrategy
+
+
+class FastbootStatus(enum.Enum):
+    unknown = 0
+    off = 1
+    flashed = 2
+    shell = 3
+
+
+@attr.s(eq=False)
+class FastbootFlashStrategy(BoardStrategy):
+    """Flash a physical board's storage over USB fastboot, then boot it.
+
+    Holding the ``recovery`` button while power comes up, then pulsing
+    ``reset``, drops the board into USB download mode. Each ``fastboot.stage`` image is
+    then staged and continued in order (e.g. SPL, then a fastboot-capable
+    U-Boot), and each ``fastboot.flash`` partition is written, except those
+    set to null (how a variant drops one of the base board's). File names are
+    relative to ``fastboot.image_dir``.
+    """
+
+    bindings = {
+        "power": "PowerProtocol",
+        "console": "ConsoleProtocol",
+        "shell": "ShellDriver",
+        "fastboot": "AndroidFastbootDriver",
+        "recovery": "DigitalOutputProtocol",
+        "reset": "DigitalOutputProtocol",
+    }
+
+    status = attr.ib(default=FastbootStatus.unknown)
+
+    def __attrs_post_init__(self):
+        super().__attrs_post_init__()
+        self.flashed = False
+
+    def _image(self, name: str) -> str:
+        return str(Path(self.manifest["fastboot"]["image_dir"]) / name)
+
+    def _enter_download_mode(self):
+        fb = self.manifest["fastboot"]
+        press = fb.get("press_time", 1)
+        self.target.activate(self.recovery)
+        self.target.activate(self.reset)
+        self.target.activate(self.power)
+        # Hold recovery across power-up (enters download mode if the board
+        # starts on power) and a reset pulse (if it was already running).
+        self.recovery.set(True)
+        time.sleep(press)
+        # cycle(), not on(): transition(off) only just cut power, and a relay
+        # flipped back within milliseconds never actually drops the board.
+        self.power.cycle()
+        time.sleep(fb.get("power_on_delay", 2))
+        self.reset.set(True)
+        time.sleep(press)
+        self.reset.set(False)
+        # Keep holding recovery until the boot ROM has sampled it.
+        time.sleep(press)
+        self.recovery.set(False)
+
+    def _stage(self, remote_path: str):
+        fb = self.manifest["fastboot"]
+        retries = fb.get("stage_retries", 5)
+        # After a continue, the previous stage's USB device lingers until the
+        # next one (e.g. FSBL, after DDR training) re-enumerates, and writes to
+        # it fail. fastboot waits for a missing device but not a stale one.
+        for attempt in range(retries):
+            try:
+                self.fastboot("stage", remote_path)
+                return
+            except subprocess.CalledProcessError:
+                if attempt == retries - 1:
+                    raise
+                time.sleep(fb.get("continue_delay", 3))
+
+    def _flash(self):
+        fb = self.manifest["fastboot"]
+        # Copy staged images to the exporter up front: the boot ROM's download
+        # mode doesn't wait around for slow transfers.
+        staged = []
+        for image in fb.get("stage", []):
+            mf = ManagedFile(self._image(image), self.fastboot.fastboot)
+            mf.sync_to_resource()
+            staged.append(mf.get_remote_path())
+        self._enter_download_mode()
+        self.target.activate(self.fastboot)
+        for remote_path in staged:
+            self._stage(remote_path)
+            self.fastboot.continue_boot()
+            time.sleep(fb.get("continue_delay", 3))
+        for partition, image in fb["flash"].items():
+            if image is None:  # a variant nulls out a base-board partition
+                continue
+            self.fastboot.flash(partition, self._image(image))
+        self.target.deactivate(self.fastboot)
+
+    def transition(self, status):
+        if not isinstance(status, FastbootStatus):
+            status = FastbootStatus[status]
+        if status == FastbootStatus.unknown:
+            raise StrategyError(f"can not transition to {status}")
+        elif status == self.status:
+            return
+        elif status == FastbootStatus.off:
+            self.target.deactivate(self.console)
+            self.target.activate(self.power)
+            self.power.off()
+        elif status == FastbootStatus.flashed:
+            self.transition(FastbootStatus.off)
+            if not self.flashed:
+                self._flash()
+                self.flashed = True
+        elif status == FastbootStatus.shell:
+            self.transition(FastbootStatus.flashed)
+            self.target.activate(self.console)
+            self.power.cycle()
+            self.target.activate(self.shell)
+        else:
+            raise StrategyError(f"no transition found from {self.status} to {status}")
+        self.status = status
+
+    def force(self, status):
+        if not isinstance(status, FastbootStatus):
+            status = FastbootStatus[status]
+        if status == FastbootStatus.off:
+            self.target.activate(self.power)
+        elif status == FastbootStatus.shell:
+            self.target.activate(self.shell)
+        else:
+            raise StrategyError(f"can not force state {status}")
+        self.status = status

labgrid_boardkit/strategies/qemu.py

@@ -0,0 +1,86 @@
+import enum
+
+import attr
+from labgrid.factory import target_factory
+from labgrid.step import step
+from labgrid.strategy.common import StrategyError
+
+from labgrid_boardkit.strategies.base import BoardStrategy
+
+
+class QemuStatus(enum.Enum):
+    unknown = 0
+    off = 1
+    booting = 2
+    shell = 3
+
+
+@attr.s(eq=False)
+class QemuBootStrategy(BoardStrategy):
+    """Boot a QEMU-based target."""
+
+    bindings = {
+        "qemu_driver": "QEMUDriver",
+        "shell": "ShellDriver",
+    }
+
+    status = attr.ib(default=QemuStatus.unknown)
+
+    @step(title="transition")
+    def transition(self, status):
+        if not isinstance(status, QemuStatus):
+            status = QemuStatus[status]
+
+        if status == QemuStatus.off:
+            if self.status == QemuStatus.shell:
+                self.target.deactivate(self.shell)
+                self.qemu_driver.off()
+                self.target.deactivate(self.qemu_driver)
+            self.status = QemuStatus.off
+        elif status == QemuStatus.shell:
+            if self.status == QemuStatus.shell:
+                return
+            if self.status == QemuStatus.booting:
+                raise StrategyError("Cannot go to shell directly from booting; turn off first.")
+            self.target.activate(self.qemu_driver)
+            self.qemu_driver.on()
+            self.status = QemuStatus.booting
+            self.target.activate(self.shell)
+            self.status = QemuStatus.shell
+        else:
+            raise StrategyError(f"Unknown status {status}")
+
+
+@target_factory.reg_driver
+@attr.s(eq=False)
+class ExternalQemuStrategy(BoardStrategy):
+    """Drive a QEMU guest whose serial console is a subprocess's stdio.
+
+    Used with ``ExternalConsoleDriver`` when QEMU runs somewhere labgrid's
+    ``QEMUDriver`` can't reach, e.g. ``ssh -tt <board> qemu-system-* -nographic``.
+    Activating the console starts the subprocess (boots the guest);
+    deactivating it kills the subprocess (and, via SIGHUP, the guest).
+    """
+
+    bindings = {
+        "console": "ConsoleProtocol",
+        "shell": "ShellDriver",
+    }
+
+    status = attr.ib(default=QemuStatus.unknown)
+
+    @step(title="transition")
+    def transition(self, status):
+        if not isinstance(status, QemuStatus):
+            status = QemuStatus[status]
+
+        if status == QemuStatus.off:
+            self.target.deactivate(self.console)
+        elif status == QemuStatus.shell:
+            if self.status == QemuStatus.shell:
+                return
+            self.target.activate(self.console)
+            self.target.activate(self.shell)
+        else:
+            raise StrategyError(f"can not transition to {status}")
+        self.status = status

labgrid_boardkit/strategies/sdmux.py

@@ -0,0 +1,81 @@
+import enum
+
+import attr
+from labgrid.driver.usbstoragedriver import Mode
+from labgrid.strategy.common import StrategyError
+
+from labgrid_boardkit.strategies.base import BoardStrategy
+
+
+class SdMuxStatus(enum.Enum):
+    unknown = 0
+    off = 1
+    flashed = 2
+    sd = 3
+
+
+@attr.s(eq=False)
+class SdMuxBootStrategy(BoardStrategy):
+    """Boot a physical board from an SD card written via USB SD-Mux.
+
+    ``image_label`` names the image entry in the labgrid client.yaml
+    ``images:`` section that holds the wic/gz path.
+    """
+
+    bindings = {
+        "power": "PowerProtocol",
+        "console": "ConsoleProtocol",
+        "shell": "ShellDriver",
+        "sdmux": "USBSDMuxDriver",
+        "sdcard": "USBStorageDriver",
+    }
+
+    status = attr.ib(default=SdMuxStatus.unknown)
+    image_label = attr.ib(default="sdimage")
+
+    def __attrs_post_init__(self):
+        super().__attrs_post_init__()
+        self.flashed = False
+
+    def transition(self, status):
+        if not isinstance(status, SdMuxStatus):
+            status = SdMuxStatus[status]
+        if status == SdMuxStatus.unknown:
+            raise StrategyError(f"can not transition to {status}")
+        elif status == self.status:
+            return
+        elif status == SdMuxStatus.off:
+            self.target.deactivate(self.console)
+            self.target.activate(self.power)
+            self.power.off()
+        elif status == SdMuxStatus.flashed:
+            image = self.target.env.config.get_image_path(self.image_label)
+            self.transition(SdMuxStatus.off)
+            if not self.flashed:
+                self.target.activate(self.sdmux)
+                self.sdmux.set_mode("host")
+                self.target.activate(self.sdcard)
+                self.sdcard.write_image(image, Mode.BMAPTOOL)
+                self.target.deactivate(self.sdcard)
+                self.sdmux.set_mode("dut")
+                self.target.deactivate(self.sdmux)
+                self.flashed = True
+        elif status == SdMuxStatus.sd:
+            self.transition(SdMuxStatus.flashed)
+            self.target.activate(self.console)
+            self.power.cycle()
+            self.target.activate(self.shell)
+        else:
+            raise StrategyError(f"no transition found from {self.status} to {status}")
+        self.status = status
+
+    def force(self, status):
+        if not isinstance(status, SdMuxStatus):
+            status = SdMuxStatus[status]
+        if status == SdMuxStatus.off:
+            self.target.activate(self.power)
+        elif status == SdMuxStatus.sd:
+            self.target.activate(self.shell)
+        else:
+            raise StrategyError(f"can not force state {status}")
+        self.status = status

labgrid_boardkit/strategies/tftp.py

@@ -0,0 +1,109 @@
+import enum
+
+import attr
+from labgrid.strategy.common import StrategyError
+
+from labgrid_boardkit import helpers
+from labgrid_boardkit.strategies.base import BoardStrategy
+
+
+class TftpStatus(enum.Enum):
+    unknown = 0
+    off = 1
+    uboot = 2
+    emmc = 3
+    tftp = 4
+
+
+@attr.s(eq=False)
+class TftpBootStrategy(BoardStrategy):
+    """Boot a physical board via U-Boot + TFTP.
+
+    Reads bootargs, tftp subdir/kernel/dtb, and load addresses from
+    ``self.manifest`` (populated by the concrete per-board subclass).
+    """
+
+    bindings = {
+        "power": "PowerProtocol",
+        "console": "ConsoleProtocol",
+        "uboot": "UBootDriver",
+        "shell": "ShellDriver",
+        "tftp": "TFTPProviderDriver",
+    }
+
+    status = attr.ib(default=TftpStatus.unknown)
+
+    def __attrs_post_init__(self):
+        super().__attrs_post_init__()
+        self.staged = False
+
+    @property
+    def bootargs(self) -> str:
+        return self.manifest["boot"]["bootargs"].strip()
+
+    def _stage(self):
+        helpers.uboot_stage(self)
+
+    def _tftp_stage_files(self):
+        boot = self.manifest["boot"]
+        tftp = self.manifest["tftp"]
+        helpers.uboot_set_server_ip(self)
+        helpers.uboot_set_bootargs(self, self.bootargs)
+        helpers.uboot_tftpboot_file(self, boot["kernel_addr"], tftp["subdir"], tftp["kernel"])
+        if "dtb" in tftp:
+            # A FIT image carries its own DTB.
+            helpers.uboot_tftpboot_file(self, boot["dtb_addr"], tftp["subdir"], tftp["dtb"])
+        if "initramfs" in tftp:
+            # Staged last so U-Boot's $filesize (set by the most recent tftpboot)
+            # reflects the initramfs size for a `$ramdisk_addr_r:$filesize` boot arg.
+            helpers.uboot_tftpboot_file(
+                self, boot["ramdisk_addr"], tftp["subdir"], tftp["initramfs"]
+            )
+
+    def transition(self, status):
+        if not isinstance(status, TftpStatus):
+            status = TftpStatus[status]
+        if status == TftpStatus.unknown:
+            raise StrategyError(f"can not transition to {status}")
+        elif status == self.status:
+            return
+        elif status == TftpStatus.off:
+            self.target.deactivate(self.console)
+            self.target.activate(self.power)
+            self.power.off()
+        elif status == TftpStatus.uboot:
+            self.transition(TftpStatus.off)
+            self.target.activate(self.console)
+            self.power.cycle()
+            self.target.activate(self.uboot)
+            self._stage()
+        elif status == TftpStatus.emmc:
+            self.transition(TftpStatus.uboot)
+            self.uboot.boot("emmc")
+            self.uboot.await_boot()
+            self.target.activate(self.shell)
+        elif status == TftpStatus.tftp:
+            self.transition(TftpStatus.uboot)
+            self._tftp_stage_files()
+            self.uboot.boot("tftp")
+            self.uboot.await_boot()
+            self.target.activate(self.shell)
+            # Keep late kernel messages (e.g. async driver probe errors) off the
+            # console, where they interleave with command output; dmesg keeps them.
+            self.shell.run("dmesg -n 1")
+        else:
+            raise StrategyError(f"no transition found from {self.status} to {status}")
+        self.status = status
+
+    def force(self, status):
+        if not isinstance(status, TftpStatus):
+            status = TftpStatus[status]
+        if status == TftpStatus.off:
+            self.target.activate(self.power)
+        elif status == TftpStatus.uboot:
+            self.target.activate(self.uboot)
+        elif status in (TftpStatus.emmc, TftpStatus.tftp):
+            self.target.activate(self.shell)
+        else:
+            raise StrategyError(f"can not force state {status}")
+        self.status = status

labgrid_boardkit/templates/client-fastboot.yaml.j2

@@ -0,0 +1,55 @@
+{#- Jinja2 template for a fastboot-flash labgrid client.yaml. -#}
+{%- set n = manifest.name -%}
+{%- set fb = manifest.fastboot -%}
+{%- set strategy_class = manifest.strategy_class | default("FastbootFlashStrategy") -%}
+targets:
+  main:
+    resources:
+      RemotePlace:
+        name: {{ manifest.remote_place }}
+    drivers:
+      - SerialDriver:
+          name: '{{ n }}-console-1'
+          bindings:
+            port: 'serial'
+      - GpioDigitalOutputDriver:
+          name: '{{ n }}-power-gpio-1'
+          bindings:
+            gpio: 'power-gpio'
+      - DigitalOutputPowerDriver:
+          name: '{{ n }}-power-1'
+          bindings:
+            output: '{{ n }}-power-gpio-1'
+{%- for button in manifest.buttons %}
+      - GpioDigitalOutputDriver:
+          name: '{{ n }}-{{ button }}-gpio-1'
+          bindings:
+            gpio: '{{ button }}-gpio'
+{%- endfor %}
+      - AndroidFastbootDriver:
+          name: '{{ n }}-fastboot-1'
+          bindings:
+            fastboot: 'fastboot'
+      - ShellDriver:
+          prompt: '{{ manifest.shell.prompt }}'
+          login_prompt: '{{ manifest.shell.login_prompt }}'
+          login_timeout: 120
+          username: '{{ manifest.shell.username }}'
+          {%- if manifest.shell.password %}
+          password: '{{ manifest.shell.password }}'
+          {%- endif %}
+          name: '{{ n }}-shell-1'
+          bindings:
+            console: '{{ n }}-console-1'
+      - {{ strategy_class }}:
+          name: '{{ n }}-strategy-1'
+          bindings:
+            power: '{{ n }}-power-1'
+            console: '{{ n }}-console-1'
+            shell: '{{ n }}-shell-1'
+            fastboot: '{{ n }}-fastboot-1'
+            recovery: '{{ n }}-{{ fb.recovery_button }}-gpio-1'
+            reset: '{{ n }}-{{ fb.reset_button }}-gpio-1'
+
+imports:
+  - strategy.py

labgrid_boardkit/templates/client-qemu.yaml.j2

@@ -0,0 +1,44 @@
+{#- Jinja2 template for a QEMU labgrid env.yaml. -#}
+{%- set n = manifest.name -%}
+{%- set strategy_class = manifest.strategy_class | default("QemuBootStrategy") -%}
+{#- virtio-mmio ("-device") for e.g. riscv/arm virt, "-pci" for x86 q35/pc -#}
+{%- set virtio = "pci" if manifest.qemu.virtio_bus | default("mmio") == "pci" else "device" -%}
+imports:
+  - strategy.py
+
+targets:
+  main:
+    drivers:
+      QEMUDriver:
+        qemu_bin: {{ manifest.qemu.binary }}
+{%- if manifest.images.bios is defined %}
+        bios: {{ manifest.name }}_bios
+{%- endif %}
+        kernel: {{ manifest.name }}_kernel
+        cpu: '{{ manifest.qemu.cpu }}'
+        memory: "{{ manifest.qemu.memory }}"
+        machine: '{{ manifest.qemu.machine }}'
+        disk: {{ manifest.name }}_ext4
+        boot_args: '{{ manifest.boot.bootargs }}'
+        extra_args: >-
+          -display none
+          -device virtio-net-{{ virtio }},netdev=net0,mac=52:54:00:12:35:02
+          -netdev user,id=net0,hostfwd=tcp:127.0.0.1:{{ manifest.qemu.ssh_port }}-:22,hostfwd=tcp:127.0.0.1:{{ manifest.qemu.telnet_port }}-:23
+          -object rng-random,filename=/dev/urandom,id=rng0
+          -device virtio-rng-{{ virtio }},rng=rng0
+{%- for accel in manifest.qemu.accel | default([]) %}
+          -accel {{ accel }}
+{%- endfor %}
+      ShellDriver:
+        prompt: 'root@[a-zA-Z0-9]+:~#\s'
+        login_prompt: ' login: '
+        username: '{{ manifest.shell.username }}'
+        login_timeout: 300
+      {{ strategy_class }}: {}
+
+images:
+{%- if manifest.images.bios is defined %}
+  {{ manifest.name }}_bios: '{{ manifest.images.bios }}'
+{%- endif %}
+  {{ manifest.name }}_ext4: '{{ manifest.images.ext4 }}'
+  {{ manifest.name }}_kernel: '{{ manifest.images.kernel }}'

labgrid_boardkit/templates/client-sdmux.yaml.j2

@@ -0,0 +1,58 @@
+{#- Jinja2 template for an SD-Mux labgrid client.yaml. -#}
+{%- set n = manifest.name -%}
+{%- set strategy_class = manifest.strategy_class | default("SdMuxBootStrategy") -%}
+targets:
+  main:
+    resources:
+      RemotePlace:
+        name: {{ manifest.remote_place }}
+    drivers:
+      - SerialDriver:
+          name: '{{ n }}-console-1'
+          bindings:
+            port: 'serial'
+      - GpioDigitalOutputDriver:
+          name: '{{ n }}-power-gpio-1'
+          bindings:
+            gpio: 'power-gpio'
+      - DigitalOutputPowerDriver:
+          name: '{{ n }}-power-1'
+          bindings:
+            output: '{{ n }}-power-gpio-1'
+      - USBStorageDriver:
+          image: '{{ manifest.image.label }}'
+          bindings:
+            storage: 'sdmux'
+      - USBSDMuxDriver:
+          bindings:
+            mux: 'sdmux'
+      - ShellDriver:
+          prompt: '(\x1b\[\?2004h|\x1b\\)?root@[\w-]+:[^ ]+[#$] '
+          login_prompt: 'login: '
+          login_timeout: 120
+          username: '{{ manifest.shell.username }}'
+          {%- if manifest.shell.password %}
+          password: '{{ manifest.shell.password }}'
+          {%- endif %}
+          name: '{{ n }}-shell-1'
+          bindings:
+            console: '{{ n }}-console-1'
+      - {{ strategy_class }}:
+          name: '{{ n }}-strategy-1'
+          bindings:
+            power: '{{ n }}-power-1'
+            console: '{{ n }}-console-1'
+            shell: '{{ n }}-shell-1'
+
+images:
+  {{ manifest.image.label }}: "{{ manifest.image.path }}"
+
+{%- if manifest.tools %}
+tools:
+{%- for k, v in manifest.tools.items() %}
+  {{ k }}: '{{ v }}'
+{%- endfor %}
+{%- endif %}
+
+imports:
+  - strategy.py

labgrid_boardkit/templates/client-tftp.yaml.j2

@@ -0,0 +1,59 @@
+{#- Jinja2 template for a TFTP-boot labgrid client.yaml. -#}
+{%- set n = manifest.name -%}
+{%- set strategy_class = manifest.strategy_class | default("TftpBootStrategy") -%}
+targets:
+  main:
+    resources:
+      RemotePlace:
+        name: {{ manifest.remote_place }}
+    drivers:
+      - SerialDriver:
+          name: '{{ n }}-console-1'
+          bindings:
+            port: 'serial'
+      - GpioDigitalOutputDriver:
+          name: '{{ n }}-power-gpio-1'
+          bindings:
+            gpio: 'power-gpio'
+      - DigitalOutputPowerDriver:
+          name: '{{ n }}-power-1'
+          bindings:
+            output: '{{ n }}-power-gpio-1'
+      - TFTPProviderDriver:
+          name: '{{ n }}-tftp-1'
+          bindings:
+            provider: 'tftp'
+      - UBootDriver:
+          prompt: '{{ manifest.uboot.prompt }}'
+          autoboot: '{{ manifest.uboot.autoboot }}'
+          interrupt: '{{ manifest.uboot.interrupt }}'
+          name: '{{ n }}-uboot-1'
+          boot_commands:
+            emmc: '{{ manifest.uboot.emmc_cmd }}'
+            tftp: '{{ manifest.uboot.tftp_cmd }}'
+          bindings:
+            console: '{{ n }}-console-1'
+          login_timeout: 30
+          boot_timeout: 30
+          strip_timestamp: True
+      - ShellDriver:
+          prompt: '{{ manifest.shell.prompt }}'
+          login_prompt: '{{ manifest.shell.login_prompt }}'
+          username: '{{ manifest.shell.username }}'
+          {%- if manifest.shell.password %}
+          password: '{{ manifest.shell.password }}'
+          {%- endif %}
+          name: '{{ n }}-shell-1'
+          bindings:
+            console: '{{ n }}-console-1'
+      - {{ strategy_class }}:
+          name: '{{ n }}-strategy-1'
+          bindings:
+            power: '{{ n }}-power-1'
+            console: '{{ n }}-console-1'
+            uboot: '{{ n }}-uboot-1'
+            shell: '{{ n }}-shell-1'
+            tftp: '{{ n }}-tftp-1'
+
+imports:
+  - strategy.py

labgrid_boardkit/templates/strategy.py.j2

@@ -0,0 +1,19 @@
+"""Generated by boardkit-render from board.yaml. Do not edit.
+
+Regenerate with: uv run boardkit-render
+"""
+
+from pathlib import Path
+
+import attr
+from labgrid_boardkit.manifest import load_board
+from labgrid_boardkit.strategies import {{ family_class }}
+from labgrid.factory import target_factory
+
+
+@target_factory.reg_driver
+@attr.s(eq=False)
+class {{ class_name }}({{ family_class }}):
+    """{{ description }}"""
+
+    manifest = load_board(Path(__file__).parent)

labgrid_boardkit/tests/test_fastboot.py

@@ -0,0 +1,23 @@
+"""Shared smoke tests for boards flashed over fastboot. Auto-skipped for boards
+whose strategy isn't a FastbootFlashStrategy (see ``fastboot`` fixture in
+``labgrid_boardkit.fixtures``).
+"""
+
+import os
+
+from labgrid.driver import ExecutionError
+
+from labgrid_boardkit import helpers
+
+
+def test_uname_a(fastboot):
+    stdout = fastboot.run_check("/bin/uname -a", timeout=60.0)
+    assert helpers.kernel_version_in(os.environ.get("VERSION"), stdout[0]), stdout[0]
+
+
+def test_buildinfo(fastboot):
+    try:
+        fastboot.run_check("cat /etc/buildinfo", timeout=60.0)
+    except ExecutionError:
+        fastboot.run("ls /etc/")
+        raise