From patchwork Wed Dec 12 17:12:30 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ruslan Trofymenko X-Patchwork-Id: 153583 Delivered-To: patch@linaro.org Received: by 2002:a2e:299d:0:0:0:0:0 with SMTP id p29-v6csp2054906ljp; Wed, 12 Dec 2018 09:16:07 -0800 (PST) X-Google-Smtp-Source: AFSGD/VQ0oOTGqqIqPxiMDa25EsVYp/1owwQ3LoRIengHUxAUTsVkCndxKIMThovXWOkLuXMo5UK X-Received: by 2002:a50:bc12:: with SMTP id j18mr19959732edh.50.1544634967385; Wed, 12 Dec 2018 09:16:07 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1544634967; cv=none; d=google.com; s=arc-20160816; b=oJejiAceH6Rr8J4421pGoFcaxkvd0zE2tdzJ2EXE7qUHXIKQds8EAkdcQPsoqE1Mua TCVKgm/KsEvB/+6Mm40FK3mZdm2ijR6FeqpZrIif49fjme3CttJekMM8R6YxdEDqUjsJ ImOX/ie4eybOMMs4ZND8EE/EwiboNQXLXO/BSk4XSijVPgiBu2btbIE4epzQfdVhe4zu AbjvXoZVgRLZnBDQ3G0W65Zf2XmXS0650/dt84LSC50hxbdtSXLo9K/WnIRs35Q5YLn+ ip4hu9lLWQsN/A/QImh8rViFJlfopHDT8B1zj2SZgv8doZRGOsb6pYW72y7j7Z2RgVp3 AM8A== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:content-transfer-encoding:mime-version :list-subscribe:list-help:list-post:list-archive:list-unsubscribe :list-id:precedence:subject:cc:references:in-reply-to:message-id :date:to:from:dkim-signature; bh=AzpZW2YzKI+u+RMdStfIxIZHwTVMnEZg3eU0SJsttjk=; b=t7PlGsdOjFs3wicNGkCMPiQOsdLAl7FtIxoWN9Bn/Yms0Py3rUUnKJnnDBGp3KoX/S pB853MzuCvGvYb1+szJLXoH56eH5NZrE6geQ0JAlPDFh0c++a4of7Iq8mhieTv8AkGOQ BwUt0WQQqbxVCQ2DWFnqpwh4V3x7Soe3AJvNd5qFWWYthhkTDeNpezQl1zOkCP48nsLQ 1gZy4l6xmo2dkJ6IbcAi1ATTT28kKzDadRwP1ZHrViNUdiQIiQlaWuSqKa7SLPWKpzqt k+0eqCZEgDs7Yh4PcNZamf5agA7OtgUchk9TY8gAX+j9d33c1oIvrH6kG5y8NMgi7fsq 2LSQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=neutral (body hash did not verify) header.i=@linaro.org header.s=google header.b=OrbXIVvb; spf=pass (google.com: best guess record for domain of u-boot-bounces@lists.denx.de designates 81.169.180.215 as permitted sender) smtp.mailfrom=u-boot-bounces@lists.denx.de; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from lists.denx.de (dione.denx.de. [81.169.180.215]) by mx.google.com with ESMTP id i25si2689281edj.422.2018.12.12.09.16.06; Wed, 12 Dec 2018 09:16:07 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of u-boot-bounces@lists.denx.de designates 81.169.180.215 as permitted sender) client-ip=81.169.180.215; Authentication-Results: mx.google.com; dkim=neutral (body hash did not verify) header.i=@linaro.org header.s=google header.b=OrbXIVvb; spf=pass (google.com: best guess record for domain of u-boot-bounces@lists.denx.de designates 81.169.180.215 as permitted sender) smtp.mailfrom=u-boot-bounces@lists.denx.de; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: by lists.denx.de (Postfix, from userid 105) id A964EC22760; Wed, 12 Dec 2018 17:14:04 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on lists.denx.de X-Spam-Level: X-Spam-Status: No, score=0.0 required=5.0 tests=RCVD_IN_MSPIKE_H2, T_DKIM_INVALID autolearn=unavailable autolearn_force=no version=3.4.0 Received: from lists.denx.de (localhost [IPv6:::1]) by lists.denx.de (Postfix) with ESMTP id 9F9C0C229B9; Wed, 12 Dec 2018 17:12:55 +0000 (UTC) Received: by lists.denx.de (Postfix, from userid 105) id EB547C229A5; Wed, 12 Dec 2018 17:12:46 +0000 (UTC) Received: from mail-lj1-f195.google.com (mail-lj1-f195.google.com [209.85.208.195]) by lists.denx.de (Postfix) with ESMTPS id 23DA5C22769 for ; Wed, 12 Dec 2018 17:12:42 +0000 (UTC) Received: by mail-lj1-f195.google.com with SMTP id e5-v6so16966699lja.4 for ; Wed, 12 Dec 2018 09:12:42 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=cEBdtUWsKkR3rJe4eze4AquublkCUISct9IxrA4jeJA=; b=OrbXIVvb7tKb1IQhkkVWd1iuXNIjTEhIhoYtw/cBVGEiBxnT17AAeh+CNLDgQK8Sq/ vIYEfDmAtQ3F/2uVX8HDYtOlxz7if5yywHBUdaF5n3pN4jGIB/YFO1Z0k0hjUUHiWQYy tPHQvZuRoAAzNrrftIkP4TkjQkYg8cHRNctaI= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=cEBdtUWsKkR3rJe4eze4AquublkCUISct9IxrA4jeJA=; b=ULtO/dDWBjw0JJ187pzJS3fHoRF4fIFdejPmZGQWQhIhHRmctAMm86PjZhy13qTEkc Vbbtk3tJ6hTVBxQFECuu58b/eKqrQso84zuDzkt6diO1Lyqy4Y6fUEPtIhn1McLHpm8K ORovj0oXY3YaBmEKivQdkSB9X810jf2CSSFmUUNg4AVWC/guvUz8kz2oy59hRR1tq238 46sXg9M5GcyNlgX3IQudqDit2FvUbHLO9dma50guEtTglIz4M6ncVuHpSOGW46H0nuR3 rsJVnyuIr4O18luQJPc5sFQd86ufxQTylepAVRkdt1VygAO5e5YC7Uw6EJSe0ASFTeg9 1BlQ== X-Gm-Message-State: AA+aEWZ2Pxdc6RaCneM29Wi6+X79BbzBABLs0ITWy8H8PIcb2Yv8dAQT cUh/PVmt29+iBrPRz4hWqNlx3wqCauo= X-Received: by 2002:a2e:9d86:: with SMTP id c6-v6mr12570344ljj.146.1544634760626; Wed, 12 Dec 2018 09:12:40 -0800 (PST) Received: from kbp1-dhp-f54913.synapse.com ([195.238.92.132]) by smtp.gmail.com with ESMTPSA id t81sm3358020lfe.84.2018.12.12.09.12.39 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Wed, 12 Dec 2018 09:12:40 -0800 (PST) From: Ruslan Trofymenko To: u-boot@lists.denx.de Date: Wed, 12 Dec 2018 19:12:30 +0200 Message-Id: <1544634754-3435-4-git-send-email-ruslan.trofymenko@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1544634754-3435-1-git-send-email-ruslan.trofymenko@linaro.org> References: <1544634754-3435-1-git-send-email-ruslan.trofymenko@linaro.org> Cc: Tom Rini , Praneeth Bajjuri , Alistair Strachan Subject: [U-Boot] [PATCH v2 3/7] common: Implement A/B metadata X-BeenThere: u-boot@lists.denx.de X-Mailman-Version: 2.1.18 Precedence: list List-Id: U-Boot discussion List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , MIME-Version: 1.0 Errors-To: u-boot-bounces@lists.denx.de Sender: "U-Boot" This patch determines the A/B-specific bootloader message structure that is the basis for implementation of recovery and A/B update functions. A/B metadata is stored in this structure and used to decide which slot should we use to boot the device. Also some basic functions for A/B metadata manipulation are implemented (like slot selection). The patch was extracted from commits [1], [2] with some coding style fixes. [1] https://android-review.googlesource.com/c/platform/external/u-boot/+/729878/2 [2] https://android-review.googlesource.com/c/platform/external/u-boot/+/729880/2 Signed-off-by: Ruslan Trofymenko Reviewed-by: Sam Protsenko --- Changes in v2: * Function return codes are clarified * Some types and constants are renamed (for compactness) * android_bootloader_message.h is renamed to android_bl_msg.h * 'debug' calls are changed to 'log_debug' * Order of headers is changed * android_bl_msg.h was synced with AOSP master counterpart common/Kconfig | 10 ++ common/Makefile | 1 + common/android_ab.c | 277 +++++++++++++++++++++++++++++++++++++++++++++++ include/android_ab.h | 34 ++++++ include/android_bl_msg.h | 169 +++++++++++++++++++++++++++++ 5 files changed, 491 insertions(+) create mode 100644 common/android_ab.c create mode 100644 include/android_ab.h create mode 100644 include/android_bl_msg.h diff --git a/common/Kconfig b/common/Kconfig index 57bd16d..0ff4679 100644 --- a/common/Kconfig +++ b/common/Kconfig @@ -748,6 +748,16 @@ config UPDATE_TFTP_MSEC_MAX default 100 depends on UPDATE_TFTP +config ANDROID_AB + bool "Android A/B updates" + default n + help + If enabled, adds support for the new Android A/B update model. This + allows the bootloader to select which slot to boot from based on the + information provided by userspace via the Android boot_ctrl HAL. This + allows a bootloader to try a new version of the system but roll back + to previous version if the new one didn't boot all the way. + endmenu menu "Blob list" diff --git a/common/Makefile b/common/Makefile index 65d89dc..acc3851 100644 --- a/common/Makefile +++ b/common/Makefile @@ -104,6 +104,7 @@ endif endif obj-y += image.o +obj-$(CONFIG_ANDROID_AB) += android_ab.o obj-$(CONFIG_ANDROID_BOOT_IMAGE) += image-android.o obj-$(CONFIG_$(SPL_TPL_)OF_LIBFDT) += image-fdt.o obj-$(CONFIG_$(SPL_TPL_)FIT) += image-fit.o diff --git a/common/android_ab.c b/common/android_ab.c new file mode 100644 index 0000000..dda2263 --- /dev/null +++ b/common/android_ab.c @@ -0,0 +1,277 @@ +// SPDX-License-Identifier: BSD-2-Clause +/* + * Copyright (C) 2017 The Android Open Source Project + */ + +#include +#include +#include +#include +#include + +/** + * Compute the CRC-32 of the bootloader control struct. + * + * Only the bytes up to the crc32_le field are considered for the CRC-32 + * calculation. + */ +static uint32_t ab_control_compute_crc(struct andr_bl_control *abc) +{ + return crc32(0, (void *)abc, offsetof(typeof(*abc), crc32_le)); +} + +/** + * Initialize andr_bl_control to the default value. + * + * It allows us to boot all slots in order from the first one. This value + * should be used when the bootloader message is corrupted, but not when + * a valid message indicates that all slots are unbootable. + */ +static void ab_control_default(struct andr_bl_control *abc) +{ + int i; + const struct andr_slot_metadata metadata = { + .priority = 15, + .tries_remaining = 7, + .successful_boot = 0, + .verity_corrupted = 0, + .reserved = 0 + }; + + memcpy(abc->slot_suffix, "a\0\0\0", 4); + abc->magic = ANDROID_BOOT_CTRL_MAGIC; + abc->version = ANDROID_BOOT_CTRL_VERSION; + abc->nb_slot = ANDROID_NUM_SLOTS; + memset(abc->reserved0, 0, sizeof(abc->reserved0)); + for (i = 0; i < abc->nb_slot; ++i) + abc->slot_info[i] = metadata; + + memset(abc->reserved1, 0, sizeof(abc->reserved1)); + abc->crc32_le = ab_control_compute_crc(abc); +} + +/** + * Load the boot_control struct from disk into newly allocated memory. + * + * This function allocates and returns an integer number of disk blocks, + * based on the block size of the passed device to help performing a + * read-modify-write operation on the boot_control struct. + * The boot_control struct offset (2 KiB) must be a multiple of the device + * block size, for simplicity. + * + * @param[in] dev_desc Device where to read the boot_control struct from + * @param[in] part_info Partition in 'dev_desc' where to read from, normally + * the "misc" partition should be used + * @param[out] pointer to pointer to andr_bl_control data + * @return 0 on success and a negative on error + */ +static int ab_control_create_from_disk(struct blk_desc *dev_desc, + const disk_partition_t *part_info, + struct andr_bl_control **abc) +{ + ulong abc_offset, abc_blocks; + + abc_offset = offsetof(struct andr_bl_msg_ab, slot_suffix); + if (abc_offset % part_info->blksz) { + printf("ANDROID: Boot control block not block aligned.\n"); + return -EINVAL; + } + abc_offset /= part_info->blksz; + + abc_blocks = DIV_ROUND_UP(sizeof(struct andr_bl_control), + part_info->blksz); + if (abc_offset + abc_blocks > part_info->size) { + printf("ANDROID: boot control partition too small. Need at"); + printf(" least %lu blocks but have %lu blocks.\n", + abc_offset + abc_blocks, part_info->size); + return -EINVAL; + } + *abc = malloc_cache_aligned(abc_blocks * part_info->blksz); + if (!*abc) + return -ENOMEM; + + if (blk_dread(dev_desc, part_info->start + abc_offset, abc_blocks, + *abc) != abc_blocks) { + printf("ANDROID: Could not read from boot control partition\n"); + free(*abc); + return -EIO; + } + log_debug("ANDROID: Loaded ABC, %lu blocks\n", abc_blocks); + return 0; +} + +/** + * Store the loaded boot_control block. + * + * Store back to the same location it was read from with + * ab_control_create_from_misc(). + * + * @param[in] dev_desc Device where we should write the boot_control struct + * @param[in] part_info Partition on the 'dev_desc' where to write + * @param[in] abc Pointer to the boot control struct and the extra bytes after + * it up to the nearest block boundary + * @return 0 on success and a negative on error + */ +static int ab_control_store(struct blk_desc *dev_desc, + const disk_partition_t *part_info, + struct andr_bl_control *abc) +{ + ulong abc_offset, abc_blocks; + + abc_offset = offsetof(struct andr_bl_msg_ab, slot_suffix) / + part_info->blksz; + abc_blocks = DIV_ROUND_UP(sizeof(struct andr_bl_control), + part_info->blksz); + if (blk_dwrite(dev_desc, part_info->start + abc_offset, abc_blocks, + abc) != abc_blocks) { + printf("ANDROID: Could not write back the misc partition\n"); + return -EIO; + } + return 0; +} + +/** + * Compare two slots. + * + * The function determines slot which is should we boot from among the two. + * + * @param[in] a The first bootable slot metadata + * @param[in] b The second bootable slot metadata + * @return Negative if the slot "a" is better, positive of the slot "b" is + * better or 0 if they are equally good. + */ +static int ab_compare_slots(const struct andr_slot_metadata *a, + const struct andr_slot_metadata *b) +{ + /* Higher priority is better */ + if (a->priority != b->priority) + return b->priority - a->priority; + + /* Higher successful_boot value is better, in case of same priority */ + if (a->successful_boot != b->successful_boot) + return b->successful_boot - a->successful_boot; + + /* Higher tries_remaining is better to ensure round-robin */ + if (a->tries_remaining != b->tries_remaining) + return b->tries_remaining - a->tries_remaining; + + return 0; +} + +int ab_select_slot(struct blk_desc *dev_desc, disk_partition_t *part_info) +{ + struct andr_bl_control *abc = NULL; + u32 crc32_le; + int slot, i, ret; + bool store_needed = false; + char slot_suffix[4]; + + ret = ab_control_create_from_disk(dev_desc, part_info, &abc); + if (!abc || ret < 0) { + /* + * This condition represents an actual problem with the code or + * the board setup, like an invalid partition information. + * Signal a repair mode and do not try to boot from either slot. + */ + return ret; + } + + crc32_le = ab_control_compute_crc(abc); + if (abc->crc32_le != crc32_le) { + printf("ANDROID: Invalid CRC-32 (expected %.8x, found %.8x), ", + crc32_le, abc->crc32_le); + printf("re-initializing A/B metadata.\n"); + ab_control_default(abc); + store_needed = true; + } + + if (abc->magic != ANDROID_BOOT_CTRL_MAGIC) { + printf("ANDROID: Unknown A/B metadata: %.8x\n", abc->magic); + free(abc); + return -ENODATA; + } + + if (abc->version > ANDROID_BOOT_CTRL_VERSION) { + printf("ANDROID: Unsupported A/B metadata version: %.8x\n", + abc->version); + free(abc); + return -ENODATA; + } + + /* + * At this point a valid boot control metadata is stored in abc, + * followed by other reserved data in the same block. We select a with + * the higher priority slot that + * - is not marked as corrupted and + * - either has tries_remaining > 0 or successful_boot is true. + * If the selected slot has a false successful_boot, we also decrement + * the tries_remaining until it eventually becomes unbootable because + * tries_remaining reaches 0. This mechanism produces a bootloader + * induced rollback, typically right after a failed update. + */ + + /* Safety check: limit the number of slots. */ + if (abc->nb_slot > ARRAY_SIZE(abc->slot_info)) { + abc->nb_slot = ARRAY_SIZE(abc->slot_info); + store_needed = true; + } + + slot = -1; + for (i = 0; i < abc->nb_slot; ++i) { + if (abc->slot_info[i].verity_corrupted || + !abc->slot_info[i].tries_remaining) { + log_debug("ANDROID: unbootable slot %d tries: %d, ", + i, abc->slot_info[i].tries_remaining); + log_debug("corrupt: %d\n", + abc->slot_info[i].verity_corrupted); + continue; + } + log_debug("ANDROID: bootable slot %d pri: %d, tries: %d, ", + i, abc->slot_info[i].priority, + abc->slot_info[i].tries_remaining); + log_debug("corrupt: %d, successful: %d\n", + abc->slot_info[i].verity_corrupted, + abc->slot_info[i].successful_boot); + + if (slot < 0 || + ab_compare_slots(&abc->slot_info[i], + &abc->slot_info[slot]) < 0) { + slot = i; + } + } + + if (slot >= 0 && !abc->slot_info[slot].successful_boot) { + printf("ANDROID: Attempting slot %c, tries remaining %d\n", + ANDROID_BOOT_SLOT_NAME(slot), + abc->slot_info[slot].tries_remaining); + abc->slot_info[slot].tries_remaining--; + store_needed = true; + } + + if (slot >= 0) { + /* + * Legacy user-space requires this field to be set in the BCB. + * Newer releases load this slot suffix from the command line + * or the device tree. + */ + memset(slot_suffix, 0, sizeof(slot_suffix)); + slot_suffix[0] = ANDROID_BOOT_SLOT_NAME(slot); + if (memcmp(abc->slot_suffix, slot_suffix, + sizeof(slot_suffix))) { + memcpy(abc->slot_suffix, slot_suffix, + sizeof(slot_suffix)); + store_needed = true; + } + } + + if (store_needed) { + abc->crc32_le = ab_control_compute_crc(abc); + ab_control_store(dev_desc, part_info, abc); + } + free(abc); + + if (slot < 0) + return -EINVAL; + + return slot; +} diff --git a/include/android_ab.h b/include/android_ab.h new file mode 100644 index 0000000..c1b901d --- /dev/null +++ b/include/android_ab.h @@ -0,0 +1,34 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ +/* + * Copyright (C) 2017 The Android Open Source Project + */ + +#ifndef __ANDROID_AB_H +#define __ANDROID_AB_H + +#include + +/* Android standard boot slot names are 'a', 'b', 'c', ... */ +#define ANDROID_BOOT_SLOT_NAME(slot_num) ('a' + (slot_num)) + +/* Number of slots */ +#define ANDROID_NUM_SLOTS 2 + +/** + * Select the slot where to boot from. + * + * On Android devices with more than one boot slot (multiple copies of the + * kernel and system images) selects which slot should be used to boot from and + * registers the boot attempt. This is used in by the new A/B update model where + * one slot is updated in the background while running from the other slot. If + * the selected slot did not successfully boot in the past, a boot attempt is + * registered before returning from this function so it isn't selected + * indefinitely. + * + * @param[in] dev_desc Place to store the device description pointer + * @param[in] part_info Place to store the partition information + * @return The slot number (>= 0) on success, or a negative on error + */ +int ab_select_slot(struct blk_desc *dev_desc, disk_partition_t *part_info); + +#endif /* __ANDROID_AB_H */ diff --git a/include/android_bl_msg.h b/include/android_bl_msg.h new file mode 100644 index 0000000..f37e01a --- /dev/null +++ b/include/android_bl_msg.h @@ -0,0 +1,169 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ +/* + * This file was taken from the AOSP Project. + * Repository: https://android.googlesource.com/platform/bootable/recovery/ + * File: bootloader_message/include/bootloader_message/bootloader_message.h + * Commit: 8b309f6970ab3b7c53cc529c51a2cb44e1c7a7e1 + * + * Copyright (C) 2008 The Android Open Source Project + */ + +#ifndef __ANDROID_BL_MSG_H +#define __ANDROID_BL_MSG_H + +/* + * compiler.h defines the types that otherwise are included from stdint.h and + * stddef.h + */ +#include +#include + +/* + * Spaces used by misc partition are as below: + * 0 - 2K Bootloader Message + * 2K - 16K Used by Vendor's bootloader (the 2K - 4K range may be optionally + * used as bootloader_message_ab struct) + * 16K - 64K Used by uncrypt and recovery to store wipe_package for A/B + * devices + * Note that these offsets are admitted by bootloader, recovery and uncrypt, so + * they are not configurable without changing all of them. + */ +#define ANDROID_MISC_BM_OFFSET 0 +#define ANDROID_MISC_WIPE_OFFSET SZ_16K + +/** + * Bootloader Message (2-KiB). + * + * This structure describes the content of a block in flash + * that is used for recovery and the bootloader to talk to + * each other. + * + * The command field is updated by linux when it wants to + * reboot into recovery or to update radio or bootloader firmware. + * It is also updated by the bootloader when firmware update + * is complete (to boot into recovery for any final cleanup) + * + * The status field is written by the bootloader after the + * completion of an "update-radio" or "update-hboot" command. + * + * The recovery field is only written by linux and used + * for the system to send a message to recovery or the + * other way around. + * + * The stage field is written by packages which restart themselves + * multiple times, so that the UI can reflect which invocation of the + * package it is. If the value is of the format "#/#" (eg, "1/3"), + * the UI will add a simple indicator of that status. + * + * We used to have slot_suffix field for A/B boot control metadata in + * this struct, which gets unintentionally cleared by recovery or + * uncrypt. Move it into struct bootloader_message_ab to avoid the + * issue. + */ +struct andr_bl_msg { + char command[32]; + char status[32]; + char recovery[768]; + + /* + * The 'recovery' field used to be 1024 bytes. It has only ever + * been used to store the recovery command line, so 768 bytes + * should be plenty. We carve off the last 256 bytes to store the + * stage string (for multistage packages) and possible future + * expansion. + */ + char stage[32]; + + /* + * The 'reserved' field used to be 224 bytes when it was initially + * carved off from the 1024-byte recovery field. Bump it up to + * 1184-byte so that the entire bootloader_message struct rounds up + * to 2048-byte. + */ + char reserved[1184]; +}; + +/** + * The A/B-specific bootloader message structure (4-KiB). + * + * We separate A/B boot control metadata from the regular bootloader + * message struct and keep it here. Everything that's A/B-specific + * stays after struct bootloader_message, which should be managed by + * the A/B-bootloader or boot control HAL. + * + * The slot_suffix field is used for A/B implementations where the + * bootloader does not set the androidboot.ro.boot.slot_suffix kernel + * commandline parameter. This is used by fs_mgr to mount /system and + * other partitions with the slotselect flag set in fstab. A/B + * implementations are free to use all 32 bytes and may store private + * data past the first NUL-byte in this field. It is encouraged, but + * not mandatory, to use 'struct bootloader_control' described below. + * + * The update_channel field is used to store the Omaha update channel + * if update_engine is compiled with Omaha support. + */ +struct andr_bl_msg_ab { + struct andr_bl_msg message; + char slot_suffix[32]; + char update_channel[128]; + + /* Round up the entire struct to 4096-byte */ + char reserved[1888]; +}; + +#define ANDROID_BOOT_CTRL_MAGIC 0x42414342 /* Bootloader Control AB */ +#define ANDROID_BOOT_CTRL_VERSION 1 + +struct andr_slot_metadata { + /* + * Slot priority with 15 meaning highest priority, 1 lowest + * priority and 0 the slot is unbootable + */ + u8 priority : 4; + /* Number of times left attempting to boot this slot */ + u8 tries_remaining : 3; + /* 1 if this slot has booted successfully, 0 otherwise */ + u8 successful_boot : 1; + /* + * 1 if this slot is corrupted from a dm-verity corruption, + * 0 otherwise + */ + u8 verity_corrupted : 1; + /* Reserved for further use */ + u8 reserved : 7; +} __packed; + +/** + * Bootloader Control AB. + * + * This struct can be used to manage A/B metadata. It is designed to + * be put in the 'slot_suffix' field of the 'bootloader_message' + * structure described above. It is encouraged to use the + * 'bootloader_control' structure to store the A/B metadata, but not + * mandatory. + */ +struct andr_bl_control { + /* NULL terminated active slot suffix */ + char slot_suffix[4]; + /* Bootloader Control AB magic number (see BOOT_CTRL_MAGIC) */ + u32 magic; + /* Version of struct being used (see BOOT_CTRL_VERSION) */ + u8 version; + /* Number of slots being managed */ + u8 nb_slot : 3; + /* Number of times left attempting to boot recovery */ + u8 recovery_tries_remaining : 3; + /* Ensure 4-bytes alignment for slot_info field */ + u8 reserved0[2]; + /* Per-slot information. Up to 4 slots */ + struct andr_slot_metadata slot_info[4]; + /* Reserved for further use */ + u8 reserved1[8]; + /* + * CRC32 of all 28 bytes preceding this field (little endian + * format) + */ + u32 crc32_le; +} __packed; + +#endif /* __ANDROID_BL_MSG_H */